[llvm-objcopy] Support -X|--discard-locals.

[rupprecht]

Summary

This adds support for the --discard-locals flag, which acts similarly to --discard-all, except it only applies to compiler-generated symbols (i.e. symbols starting with .L in ELF).

I am not sure about COFF local symbols: those appear to also use .L in most cases, but also use just L in other cases, so for now I am just leaving it unimplemented there.

Fixes PR36160

[mstorsjo]

I am not sure about COFF local symbols: those appear to also use .L in most cases, but also use just L in other cases, so for now I am just leaving it unimplemented there.

AFAIK they only use .L - however GNU objcopy seems to strip out all local symbols that start with either .L or L. On arches other than i386, where symbols have no prefix otherwise, this actually seems to get rid of any normal local symbol that happens to start with such a char.

But leaving it unimplemented here is fine by me.

[jhenderson]

Please add a test for the case where the symbol that would be discarded is referenced by a relocation, and show that it matches GNU behaviour, or at least that we are consistent with our existing behaviour.

Another behaviour to check is what happens with SHN_ABS and SHN_COMMON .L* local symbols?

llvm/test/tools/llvm-objcopy/ELF/discard-locals.test

30–40

You can simplify this a bit, by removing one of the sections, removing the content of the other section, and removing things like the flags, address and alignment fields. You don't need much of an ELF to test symbol discarding.

46–47

The size and value of these symbols is irrelevant, so let's not list them.

llvm/test/tools/llvm-objcopy/ELF/discard-mix-local-and-all.test

53

Same comments as in the other test apply here.

101

COMP-LOCAL? What does that mean? Probably better to call it something like NO-DISCARD.

llvm/tools/llvm-objcopy/CopyConfig.cpp

390–395

I just want to confirm that this matches GNU objcopy. If using both --discard-all and --discard-locals in GNU objcopy, does the last triumph, or does --discard-all always triumph, regardless of order?

llvm/tools/llvm-objcopy/CopyConfig.h

92–93

This isn't a boolean option any more, so should be elsewhere in the config.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

342–343

I don't think a number of these cases are being tested, from what I can tell. I'd expect to see the following test cases:

1. normal local symbol (e.g. STT_OBJECT) with .L prefix.
2. other normal local symbol (i.e. without .L prefix).
3. Undefined local symbol with .L prefix.
4. Local file symbol with .L prefix.
5. Local section symbol with .L prefix.
6. Global/weak symbol with .L prefix.

As things stand, the test only tests 1) and 2).

[rupprecht]

In D57248#1371694, @mstorsjo wrote:

I am not sure about COFF local symbols: those appear to also use .L in most cases, but also use just L in other cases, so for now I am just leaving it unimplemented there.

AFAIK they only use .L - however GNU objcopy seems to strip out all local symbols that start with either .L or L. On arches other than i386, where symbols have no prefix otherwise, this actually seems to get rid of any normal local symbol that happens to start with such a char.

But leaving it unimplemented here is fine by me.

I would prefer to leave it unimplemented as part of this patch, because I don't know anything about COFF :) but I can follow up with an attempt to add it specifically for COFF once all this wiring is in place

In D57248#1373312, @jhenderson wrote:

Please add a test for the case where the symbol that would be discarded is referenced by a relocation, and show that it matches GNU behaviour, or at least that we are consistent with our existing behaviour.

Added a test -- we're consistent with existing behavior, but not with GNU here. i.e.:

$ llvm-objcopy --discard-all <yaml obj from discard-locals-rel.test> /tmp/foo.o
llvm-objcopy: error: not stripping symbol '.L.rel' because it is named in a relocation.
$ llvm-objcopy --discard-locals <yaml obj from discard-locals-rel.test> /tmp/foo.o
llvm-objcopy: error: not stripping symbol '.L.rel' because it is named in a relocation.
$ objcopy --discard-locals <yaml obj from discard-locals-rel.test> /tmp/foo.o
# No errors, copies the object and avoids stripping .L.rel

I'm not sure if this is a problem in practice; I can test a bit more once this patch is committed. If it is a problem, it's an existing problem with --discard-all.

Another behaviour to check is what happens with SHN_ABS and SHN_COMMON .L* local symbols?

Added these tests, and verified we're consistent with GNU objcopy --discard-locals for these test files.

llvm/test/tools/llvm-objcopy/ELF/discard-mix-local-and-all.test

101

COMP-LOCAL is for "Compiler-generated local symbols" as it is called in documentation (at least it is in gnu man pages & as I added to --help in this patch); clarified with a comment at the top and expanded to COMPILER-LOCAL

llvm/tools/llvm-objcopy/CopyConfig.cpp

390–395

Yes, see here: https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=binutils/objcopy.c;h=0e17b863d5a7d4b95b1dfbc7aa8d6b683b85d592;hb=HEAD#l4453

  while ((c = getopt(...)) {
      switch (c) {
...
	case 'x':
	  discard_locals = LOCALS_ALL;
	  break;
	case 'X':
	  discard_locals = LOCALS_START_L;
	  break;

i.e. last one wins. This can be double checked with objcopy -x -X vs objcopy -X -x.

[rupprecht]

• Move option out of boolean-option section
• Simplify tests
• Add more test cases

[jhenderson]

Something that's worth noting is that section symbols often don't actually have a name. Some tools use their section name instead for clarity. I'm wondering if this might cause an issue for such a section symbol for a section named ".L..." e.g. ".LLVM.Custom.Section" or whatever? Definitely it deserves including in the testcase.

llvm/test/tools/llvm-objcopy/ELF/discard-locals.test

38–40

You can probably get rid of this and the LocalFile symbol below, and just keep the .L versions of those symbols. They don't provide any additional coverage.

55–57

Ditto.

61–65

These aren't local, so won't be discarded anyway (and therefore aren't testing anything). They should probably be in the local list...

[rupprecht]

In D57248#1375099, @jhenderson wrote:

Something that's worth noting is that section symbols often don't actually have a name. Some tools use their section name instead for clarity. I'm wondering if this might cause an issue for such a section symbol for a section named ".L..." e.g. ".LLVM.Custom.Section" or whatever? Definitely it deserves including in the testcase.

Added

Of note -- GNU objcopy is indeed enforcing the empty section name by clearing the symbol name when copying the .L.LocalSection symbol here. We preserve it, not sure if that matters.
Also two other differences: GNU objcopy is promoting .L.LocalFile and .L.undefined from locals to globals. Again, I think that doesn't matter too much, those files should probably be global to begin with.

llvm/test/tools/llvm-objcopy/ELF/discard-locals.test

61–65

I don't think a local SHN_COMMON symbol makes any sense, so I just removed that case, but moved the others to local... although I'm not sure the others make sense to be local either.

[rupprecht]

• Update test cases

[jhenderson]

I'm happy with this as is. LGTM.

llvm/test/tools/llvm-objcopy/ELF/discard-locals.test

61–65

I guess it depends what you mean by "make sense". At least in assembly, you can generate them (although you can't generate section symbols with names, I believe).

llvm/tools/llvm-objcopy/StripOpts.td

61

Perhaps this should be "i.e." rather than "e.g."?

[rupprecht]

llvm/tools/llvm-objcopy/StripOpts.td

61

I think .L is not universal -- it seems macho and (sometimes) COFF uses just L, and mips uses $ -- hence "e.g." as this is just ELF's example.

llvm/test/tools/llvm-objcopy/ELF/discard-locals-rel.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-objcopy --discard-locals %t %t2 2>&1 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    Info:            .text
+    Relocations:
+      - Offset: 0x1000
+        Symbol: .L.rel
+        Type:   R_X86_64_PC32
+Symbols:
+  Local:
+    - Name:     .L.rel
+      Type:     STT_FUNC
+      Section:  .text
+
+# CHECK: not stripping symbol '.L.rel' because it is named in a relocation.

llvm/test/tools/llvm-objcopy/ELF/discard-locals.test

+# RUN: yaml2obj %s > %t
+# RUN: cp %t %t1
+# RUN: llvm-objcopy --discard-locals %t %t2
+# Verify that llvm-objcopy has not modified the input.
+# RUN: cmp %t %t1
+# RUN: llvm-readobj --symbols %t2 | FileCheck %s
+
+# RUN: llvm-objcopy -X %t %t3
+# Verify that llvm-objcopy has not modified the input.
+# RUN: cmp %t %t1
+# RUN: cmp %t2 %t3
+
+# Verify that llvm-strip modifies the symbol table the same way.
+
+# RUN: cp %t %t4
+# RUN: llvm-strip --discard-locals %t4
+# RUN: cmp %t2 %t4
+
+# RUN: cp %t %t5
+# RUN: llvm-strip -X %t5
+# RUN: cmp %t2 %t5
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+  - Name:            .LLVM.Custom.Section
+    Type:            SHT_PROGBITS
+Symbols:
+  Local:
+    - Name:     Local
+      Type:     STT_FUNC
+      Section:  .text
+    - Name:     .L.LocalSection
+      Type:     STT_SECTION
+      Section:  .text
+    - Type:     STT_SECTION
+      Section:  .LLVM.Custom.Section
+    - Name:     .L.LocalFile
+      Type:     STT_FILE
+    - Name:     .L.str
+      Type:     STT_OBJECT
+      Section:  .text
+    - Name:     .L.undefined
+    - Name:     .L.abs
+      Index:    SHN_ABS
+  Global:
+    - Name:     .L.Global
+      Type:     STT_FUNC
+      Section:  .text
+
+# CHECK:      Symbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name:
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: Local
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: Function
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: .L.LocalSection
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: Section
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name:
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: Section
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: .LLVM.Custom.Section
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: .L.LocalFile
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: File
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: .L.undefined
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: .L.Global
+# CHECK-NEXT:     Value:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Function
+# CHECK-NEXT:     Other:
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]

llvm/test/tools/llvm-objcopy/ELF/discard-mix-local-and-all.test

+# RUN: yaml2obj %s > %t
+# Establish baseline objects for further checks. --discard-locals only discards
+# compiler-generated local symbols (starting with .L), --discard-all discards
+# all regular local symbols.
+# RUN: llvm-objcopy %t %t-discard-none
+# RUN: llvm-readobj --symbols %t-discard-none | FileCheck %s --check-prefixes=CHECK,LOCAL,COMPILER-LOCAL
+# RUN: llvm-objcopy --discard-all %t %t-discard-all
+# RUN: llvm-readobj --symbols %t-discard-all | FileCheck %s
+# RUN: llvm-objcopy --discard-locals %t %t-discard-locals
+# RUN: llvm-readobj --symbols %t-discard-locals | FileCheck %s --check-prefixes=CHECK,LOCAL
+
+# When mixing --discard-all and --discard-locals, the last one wins.
+# RUN: llvm-objcopy --discard-all --discard-locals %t %t.1.o
+# RUN: cmp %t.1.o %t-discard-locals
+# RUN: llvm-objcopy --discard-locals --discard-all %t %t.2.o
+# RUN: cmp %t.2.o %t-discard-all
+# RUN: llvm-objcopy -x -X %t %t.3.o
+# RUN: cmp %t.3.o %t-discard-locals
+# RUN: llvm-objcopy -X -x %t %t.4.o
+# RUN: cmp %t.4.o %t-discard-all
+# RUN: llvm-objcopy -x -X -x -X %t %t.5.o
+# RUN: cmp %t.5.o %t-discard-locals
+# RUN: llvm-objcopy -X -x -X -x %t %t.6.o
+# RUN: cmp %t.6.o %t-discard-all
+# RUN: llvm-objcopy -X -x -X -x --discard-locals %t %t.7.o
+# RUN: cmp %t.7.o %t-discard-locals
+# RUN: llvm-objcopy -X -x -X -x --discard-all %t %t.8.o
+# RUN: cmp %t.8.o %t-discard-all
+
+# llvm-strip works in the same way.
+# RUN: llvm-strip --discard-all --discard-locals %t -o %t.9.o
+# RUN: cmp %t.9.o %t-discard-locals
+# RUN: llvm-strip --discard-locals --discard-all %t -o %t.10.o
+# RUN: cmp %t.10.o %t-discard-all
+# RUN: llvm-strip -x -X %t -o %t.11.o
+# RUN: cmp %t.11.o %t-discard-locals
+# RUN: llvm-strip -X -x %t -o %t.12.o
+# RUN: cmp %t.12.o %t-discard-all
+# RUN: llvm-strip -x -X -x -X %t -o %t.13.o
+# RUN: cmp %t.13.o %t-discard-locals
+# RUN: llvm-strip -X -x -X -x %t -o %t.14.o
+# RUN: cmp %t.14.o %t-discard-all
+# RUN: llvm-strip -X -x -X -x --discard-locals %t -o %t.15.o
+# RUN: cmp %t.15.o %t-discard-locals
+# RUN: llvm-strip -X -x -X -x --discard-all %t -o %t.16.o
+# RUN: cmp %t.16.o %t-discard-all
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+Symbols:
+  Local:
+    - Name:     Local
+      Type:     STT_FUNC
+      Section:  .text
+    - Name:     .L.str
+      Type:     STT_OBJECT
+      Section:  .text
+  Global:
+    - Name:     Global
+      Type:     STT_FUNC
+      Section:  .text
+
+# CHECK:               Symbols [
+# CHECK-NEXT:            Symbol {
+# CHECK-NEXT:              Name:
+# CHECK-NEXT:              Value: 0x0
+# CHECK-NEXT:              Size: 0
+# CHECK-NEXT:              Binding: Local
+# CHECK-NEXT:              Type: None
+# CHECK-NEXT:              Other: 0
+# CHECK-NEXT:              Section: Undefined
+# CHECK-NEXT:            }
+# LOCAL-NEXT:            Symbol {
+# LOCAL-NEXT:              Name: Local
+# LOCAL-NEXT:              Value:
+# LOCAL-NEXT:              Size:
+# LOCAL-NEXT:              Binding: Local
+# LOCAL-NEXT:              Type: Function
+# LOCAL-NEXT:              Other:
+# LOCAL-NEXT:              Section: .text
+# LOCAL-NEXT:            }
+# COMPILER-LOCAL-NEXT:   Symbol {
+# COMPILER-LOCAL-NEXT:     Name: .L.str
+# COMPILER-LOCAL-NEXT:     Value:
+# COMPILER-LOCAL-NEXT:     Size:
+# COMPILER-LOCAL-NEXT:     Binding: Local
+# COMPILER-LOCAL-NEXT:     Type: Object
+# COMPILER-LOCAL-NEXT:     Other:
+# COMPILER-LOCAL-NEXT:     Section: .text
+# COMPILER-LOCAL-NEXT:   }
+# CHECK-NEXT:            Symbol {
+# CHECK-NEXT:              Name: Global
+# CHECK-NEXT:              Value:
+# CHECK-NEXT:              Size:
+# CHECK-NEXT:              Binding: Global
+# CHECK-NEXT:              Type: Function
+# CHECK-NEXT:              Other:
+# CHECK-NEXT:              Section: .text
+# CHECK-NEXT:            }
+# CHECK-NEXT:          ]

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

static Error handleArgs(const CopyConfig &Config, Object &Obj) {
   Obj.removeSections([&Config](const Section &Sec) {
     // Contrary to --only-keep-debug, --only-section fully removes sections that
     // aren't mentioned.
     if (!Config.OnlySection.empty() &&
         !is_contained(Config.OnlySection, Sec.Name))
       return true;
 
     if (Config.StripDebug || Config.StripAll || Config.StripAllGNU ||
-        Config.DiscardAll || Config.StripUnneeded) {
+        Config.DiscardMode == DiscardType::All || Config.StripUnneeded) {
       if (isDebugSection(Sec) &&
           (Sec.Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) != 0)
         return true;
     }
 
     if (is_contained(Config.ToRemove, Sec.Name))
       return true;
 
static Error handleArgs(const CopyConfig &Config, Object &Obj) {
   }
 
   // StripAll removes all symbols and thus also removes all relocations.
   if (Config.StripAll || Config.StripAllGNU)
     for (Section &Sec : Obj.getMutableSections())
       Sec.Relocs.clear();
 
   // If we need to do per-symbol removals, initialize the Referenced field.
-  if (Config.StripUnneeded || Config.DiscardAll ||
+  if (Config.StripUnneeded || Config.DiscardMode == DiscardType::All ||
       !Config.SymbolsToRemove.empty())
     if (Error E = Obj.markSymbols())
       return E;
 
   // Actually do removals of symbols.
   Obj.removeSymbols([&](const Symbol &Sym) {
     // For StripAll, all relocations have been stripped and we remove all
     // symbols.
if (!Sym.Referenced) {
       if (Config.StripUnneeded &&
           (Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC ||
            Sym.Sym.SectionNumber == 0))
         return true;
 
       // GNU objcopy keeps referenced local symbols and external symbols
       // if --discard-all is set, similar to what --strip-unneeded does,
       // but undefined local symbols are kept when --discard-all is set.
-      if (Config.DiscardAll && Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC &&
+      if (Config.DiscardMode == DiscardType::All &&
+          Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC &&
           Sym.Sym.SectionNumber != 0)
         return true;
     }
 
     return false;
   });
 
   if (!Config.AddGnuDebugLink.empty())
     addGnuDebugLink(Obj, Config.AddGnuDebugLink);
 
   if (!Config.BuildIdLinkDir.empty() || Config.BuildIdLinkInput ||
       Config.BuildIdLinkOutput || !Config.SplitDWO.empty() ||
       !Config.SymbolsPrefix.empty() || !Config.AddSection.empty() ||
       !Config.DumpSection.empty() || !Config.KeepSection.empty() ||
       !Config.SymbolsToGlobalize.empty() || !Config.SymbolsToKeep.empty() ||
       !Config.SymbolsToLocalize.empty() || !Config.SymbolsToWeaken.empty() ||
       !Config.SymbolsToKeepGlobal.empty() || !Config.SectionsToRename.empty() ||
       !Config.SetSectionFlags.empty() || !Config.SymbolsToRename.empty() ||
       Config.ExtractDWO || Config.KeepFileSymbols || Config.LocalizeHidden ||
       Config.PreserveDates || Config.StripDWO || Config.StripNonAlloc ||
-      Config.StripSections || Config.Weaken || Config.DecompressDebugSections) {
+      Config.StripSections || Config.Weaken || Config.DecompressDebugSections ||
+      Config.DiscardMode == DiscardType::Locals) {
     return createStringError(llvm::errc::invalid_argument,
                              "Option not supported by llvm-objcopy for COFF");
   }
 
   return Error::success();
 }
 
 void executeObjcopyOnBinary(const CopyConfig &Config,

llvm/tools/llvm-objcopy/CopyConfig.h

struct SectionRename {
   Optional<uint64_t> NewFlags;
 };
 
 struct SectionFlagsUpdate {
   StringRef Name;
   uint64_t NewFlags;
 };
 
+enum class DiscardType {
+  None,   // Default
+  All,    // --discard-all (-x)
+  Locals, // --discard-locals (-X)
+};
+
 // Configuration for copying/stripping a single file.
 struct CopyConfig {
   // Main input/output options
   StringRef InputFilename;
   StringRef InputFormat;
   StringRef OutputFilename;
   StringRef OutputFormat;
 
   // Only applicable for --input-format=binary
   MachineInfo BinaryArch;
   // Only applicable when --output-format!=binary (e.g. elf64-x86-64).
   Optional<MachineInfo> OutputArch;
 
   // Advanced options
   StringRef AddGnuDebugLink;
   StringRef BuildIdLinkDir;
   Optional<StringRef> BuildIdLinkInput;
   Optional<StringRef> BuildIdLinkOutput;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
+  DiscardType DiscardMode = DiscardType::None;
 
   // Repeated options
   std::vector<StringRef> AddSection;
   std::vector<StringRef> DumpSection;
   std::vector<StringRef> KeepSection;
   std::vector<StringRef> OnlySection;
   std::vector<StringRef> SymbolsToGlobalize;
   std::vector<StringRef> SymbolsToKeep;
   std::vector<StringRef> SymbolsToLocalize;
   std::vector<StringRef> SymbolsToRemove;
   std::vector<StringRef> SymbolsToWeaken;
   std::vector<StringRef> ToRemove;
   std::vector<std::string> SymbolsToKeepGlobal;
 
   // Map options
   StringMap<SectionRename> SectionsToRename;
   StringMap<SectionFlagsUpdate> SetSectionFlags;
   StringMap<StringRef> SymbolsToRename;
 
   // Boolean options
   bool DeterministicArchives = true;
-  bool DiscardAll = false;
   bool ExtractDWO = false;
   bool KeepFileSymbols = false;
   bool LocalizeHidden = false;
   bool OnlyKeepDebug = false;
   bool PreserveDates = false;
   bool StripAll = false;
   bool StripAllGNU = false;
   bool StripDWO = false;
   bool StripDebug = false;

llvm/tools/llvm-objcopy/CopyConfig.cpp

DriverConfig parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
   Config.StripUnneeded = InputArgs.hasArg(OBJCOPY_strip_unneeded);
   Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
   Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
   Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);
-  Config.DiscardAll = InputArgs.hasArg(OBJCOPY_discard_all);
+  if (InputArgs.hasArg(OBJCOPY_discard_all, OBJCOPY_discard_locals))
+    Config.DiscardMode =
+        InputArgs.hasFlag(OBJCOPY_discard_all, OBJCOPY_discard_locals)
+            ? DiscardType::All
+            : DiscardType::Locals;
   Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
   Config.KeepFileSymbols = InputArgs.hasArg(OBJCOPY_keep_file_symbols);
   Config.DecompressDebugSections =
       InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
     Config.SymbolsToLocalize.push_back(Arg->getValue());
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
     Config.SymbolsToKeepGlobal.push_back(Arg->getValue());
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
if (Positional.empty())
     error("No input file specified");
 
   if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
     error("Multiple input files cannot be used in combination with -o");
 
   CopyConfig Config;
   Config.StripDebug = InputArgs.hasArg(STRIP_strip_debug);
 
-  Config.DiscardAll = InputArgs.hasArg(STRIP_discard_all);
+  if (InputArgs.hasArg(STRIP_discard_all, STRIP_discard_locals))
+    Config.DiscardMode =
+        InputArgs.hasFlag(STRIP_discard_all, STRIP_discard_locals)
+            ? DiscardType::All
+            : DiscardType::Locals;
   Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
   Config.StripAll = InputArgs.hasArg(STRIP_strip_all);
   Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
 
-  if (!Config.StripDebug && !Config.StripUnneeded && !Config.DiscardAll &&
-      !Config.StripAllGNU)
+  if (!Config.StripDebug && !Config.StripUnneeded &&
+      Config.DiscardMode == DiscardType::None && !Config.StripAllGNU)
     Config.StripAll = true;
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_section))
     Config.KeepSection.push_back(Arg->getValue());
 
   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
     Config.ToRemove.push_back(Arg->getValue());
 

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

if (Config.StripUnneeded) {
         Section.markSymbols();
     }
 
     Obj.removeSymbols([&](const Symbol &Sym) {
       if (is_contained(Config.SymbolsToKeep, Sym.Name) ||
           (Config.KeepFileSymbols && Sym.Type == STT_FILE))
         return false;
 
-      if (Config.DiscardAll && Sym.Binding == STB_LOCAL &&
-          Sym.getShndx() != SHN_UNDEF && Sym.Type != STT_FILE &&
-          Sym.Type != STT_SECTION)
+      if ((Config.DiscardMode == DiscardType::All ||
+           (Config.DiscardMode == DiscardType::Locals &&
+            StringRef(Sym.Name).startswith(".L"))) &&
+          Sym.Binding == STB_LOCAL && Sym.getShndx() != SHN_UNDEF &&
+          Sym.Type != STT_FILE && Sym.Type != STT_SECTION)
         return true;
 
       if (Config.StripAll || Config.StripAllGNU)
         return true;
 
       if (is_contained(Config.SymbolsToRemove, Sym.Name))
         return true;
 

llvm/tools/llvm-objcopy/ObjcopyOpts.td

: Eq<"keep-global-symbols",
          "be repeated to read symbols from many files.">,
       MetaVarName<"filename">;
 
 defm weaken_symbol : Eq<"weaken-symbol", "Mark <symbol> as weak">,
                      MetaVarName<"symbol">;
 def W : JoinedOrSeparate<["-"], "W">, Alias<weaken_symbol>;
 def weaken : Flag<["-", "--"], "weaken">,
              HelpText<"Mark all global symbols as weak">;
+
+def discard_locals : Flag<["-", "--"], "discard-locals">,
+                     HelpText<"Remove compiler-generated local symbols, (e.g. "
+                              "symbols starting with .L)">;
+def X : Flag<["-"], "X">, Alias<discard_locals>;
+
 def discard_all
     : Flag<["-", "--"], "discard-all">,
       HelpText<"Remove all local symbols except file and section symbols">;
 def x : Flag<["-"], "x">, Alias<discard_all>;
 defm strip_symbol : Eq<"strip-symbol", "Remove symbol <symbol>">,
                     MetaVarName<"symbol">;
 def N : JoinedOrSeparate<["-"], "N">, Alias<strip_symbol>;
 defm keep_symbol : Eq<"keep-symbol", "Do not remove symbol <symbol>">,

llvm/tools/llvm-objcopy/StripOpts.td

 def R : JoinedOrSeparate<["-"], "R">, Alias<remove_section>;
 
 defm keep_section : Eq<"keep-section", "Keep <section>">,
                     MetaVarName<"section">;
 defm keep_symbol : Eq<"keep-symbol", "Do not remove symbol <symbol>">,
                    MetaVarName<"symbol">;
 def K : JoinedOrSeparate<["-"], "K">, Alias<keep_symbol>;
 
+def discard_locals : Flag<["-", "--"], "discard-locals">,
+                     HelpText<"Remove compiler-generated local symbols, (e.g. "
+                              "symbols starting with .L)">;
+def X : Flag<["-"], "X">, Alias<discard_locals>;
+
 def discard_all
     : Flag<["-", "--"], "discard-all">,
       HelpText<"Remove all local symbols except file and section symbols">;
 def x : Flag<["-"], "x">, Alias<discard_all>;
 
 def version : Flag<["-", "--"], "version">,
               HelpText<"Print the version and exit.">;
 def V : Flag<["-"], "V">, Alias<version>;