[objcopy][NFC] Move NameOrPattern::create() into CommonConfig.h

[avl]

Summary

While moving objcopy into separate library(D88827), NameOrPattern::create()
was mistakenly placed into ObjcopyOptions.cpp. This patch moves
the NameOrPattern::create() into CommonConfig.h. Additionally it adds
test for using NameOrPattern.

[jhenderson]

llvm/include/llvm/ObjCopy/CommonConfig.h

113–115 ↗

(On Diff #413035)

Given the complexity of this function, I think it should be in a .cpp file.

llvm/unittests/ObjCopy/ObjCopyTest.cpp

400–403

It seems to me like this function has a lot of copied code in it. I think you should be able to share most of it rather than just copying.

413

470

If this YAML is identical to other cases, pull it into a shared constant somewhere.

[avl]

addressed comments(moved NameOrPattern::create() into .cpp, splitted functions into several smaller in ObjCopyTest.cpp)

[avl]

llvm/unittests/ObjCopy/ObjCopyTest.cpp

470

I suggest to not use shared constants here. These are different places(even if yaml descriptions look similar). Changing in one place should not necessarily be reflected in others. Also it is more convenient to see them inplace rather then moved to constant definition.

Though if you still think we need shared constants here - will update the patch accordingly.

[jhenderson]

llvm/lib/ObjCopy/CommonConfig.cpp

17

I'm not sure you need the llvm:: prefix.

llvm/unittests/ObjCopy/ObjCopyTest.cpp

142

Nit here and below: LLVM style says use loweer case for start of error messages.

152

Sec is a more common abbreviation for "section". Applies elsewhere too.

153

165

188

Maybe?

418

Do you need the trailing return type?

470

I think it should be shared: if at some point it needs to be unshared, people can make the required change then. Similarly, future developers should be careful not to make changes to shared code without understanding the implications.

As a direct counterpoint to your comment: what if e.g. the YAML format changed slightly, necessitating a change to the input strings: you wouldn't want to modify the same s tring multiple timesm would you?

[avl]

llvm/unittests/ObjCopy/ObjCopyTest.cpp

470

I think it should be shared: if at some point it needs to be unshared, people can make the required change then. Similarly, future developers should be careful not to make changes to shared code without understanding the implications.

Ok, would change to shared constants.

As a direct counterpoint to your comment: what if e.g. the YAML format changed slightly, necessitating a change to the input strings: you wouldn't want to modify the same s tring multiple timesm would you?

That would be mechanical search&replace. It looks not a problem from my point of view.

[jhenderson]

llvm/unittests/ObjCopy/ObjCopyTest.cpp

470

That would be mechanical search&replace. It looks not a problem from my point of view.

Assuming the developer knew there were multiple places to change and the nature of the change is straightforward enough to be amenable to that.

[avl]

addressed comments.

[jhenderson]

LGTM, with one suggestion.

llvm/unittests/ObjCopy/ObjCopyTest.cpp

24–107

Simpler name: SimpleFileCOFFYAML. Similar for the others.

[avl]

Ok. Thanks!

llvm/lib/ObjCopy/CMakeLists.txt

source_group("Source Files\\wasm" REGULAR_EXPRESSION
   wasm/.*[.]cpp
 )
 source_group("Source Files\\XCOFF" REGULAR_EXPRESSION
   XCOFF/.*[.]cpp
 )
 
 add_llvm_component_library(LLVMObjCopy
   Archive.cpp
+  CommonConfig.cpp
   ObjCopy.cpp
   ConfigManager.cpp
   COFF/COFFObjcopy.cpp
   COFF/COFFObject.cpp
   COFF/COFFReader.cpp
   COFF/COFFWriter.cpp
   ELF/ELFObjcopy.cpp
   ELF/ELFObject.cpp

llvm/lib/ObjCopy/CommonConfig.cpp

+//===- CommonConfig.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/ObjCopy/CommonConfig.h"
+
+namespace llvm {
+namespace objcopy {
+
+Expected<NameOrPattern>
+NameOrPattern::create(StringRef Pattern, MatchStyle MS,
+                      function_ref<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;
+    return NameOrPattern(std::make_shared<Regex>(
+        ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data)));
+  }
+  }
+  llvm_unreachable("Unhandled llvm.objcopy.MatchStyle enum");
+}
+
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

if (!TrimmedLine.empty())
       if (Error E = Symbols.addMatcher(NameOrPattern::create(
               Saver.save(TrimmedLine), MS, ErrorCallback)))
         return E;
   }
 
   return Error::success();
 }
 
-Expected<NameOrPattern>
-NameOrPattern::create(StringRef Pattern, MatchStyle MS,
-                      function_ref<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;
-    return NameOrPattern(std::make_shared<Regex>(
-        ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data)));
-  }
-  }
-  llvm_unreachable("Unhandled llvm.objcopy.MatchStyle enum");
-}
-
 static Error addSymbolsToRenameFromFile(StringMap<StringRef> &SymbolsToRename,
                                         BumpPtrAllocator &Alloc,
                                         StringRef Filename) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
   if (!BufOrErr)
     return createFileError(Filename, BufOrErr.getError());

llvm/unittests/ObjCopy/ObjCopyTest.cpp

 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace object;
 using namespace objcopy;
 using namespace yaml;
 
-void copySimpleInMemoryFileImpl(
-    const char *YamlCreationString,
-    std::function<bool(const Binary &File)> IsValidFormat) {
+const char *SimpleFileCOFFYAML = R"(
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            .text
+    Characteristics: [  ]
+    Alignment:       4
+    SectionData:     E800000000C3C3C3
+symbols:
+...
+)";
+
+const char *SimpleFileELFYAML = R"(
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:        "12345678"
+)";
+
+const char *SimpleFileMachOYAML = R"(
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x80000003
+  filetype:        0x00000001
+  ncmds:           1
+  sizeofcmds:      152
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         152
+    segname:         __TEXT
+    vmaddr:          0
+    vmsize:          4
+    fileoff:         184
+    filesize:        4
+    maxprot:         7
+    initprot:        7
+    nsects:          1
+    flags:           0
+    Sections:
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000000000000
+        content:         'AABBCCDD'
+        size:            4
+        offset:          184
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+...
+)";
+
+const char *SimpleFileWasmYAML = R"(
+--- !WASM
+FileHeader:
+  Version:         0x00000001
+Sections:
+  - Type: CUSTOM
+    Name: text
+    Payload: ABC123
+...
+)";
+
+// Create ObjectFile from \p YamlCreationString and do validation using \p
+// IsValidFormat checker. \p Storage is a storage for data. \returns created
+// ObjectFile.
+Expected<std::unique_ptr<ObjectFile>> createObjectFileFromYamlDescription(
+    const char *YamlCreationString, SmallVector<char> &Storage,
+    function_ref<bool(const Binary &File)> IsValidFormat) {
   auto ErrHandler = [&](const Twine &Msg) { FAIL() << "Error: " << Msg; };
 
-  // Create Object file from YAML description.
-  SmallVector<char> Storage;
   std::unique_ptr<ObjectFile> Obj =
       yaml2ObjectFile(Storage, YamlCreationString, ErrHandler);
-  ASSERT_TRUE(Obj);
-  ASSERT_TRUE(IsValidFormat(*Obj));
+  if (!Obj)
+    return createError("could not create ObjectFile from yaml description");
 
-  ConfigManager Config;
-  Config.Common.OutputFilename = "a.out";
+  if (!IsValidFormat(*Obj))
+    return createError("wrong file format");
 
-  // Call executeObjcopyOnBinary()
-  SmallVector<char> DataVector;
+  return Obj;
+}
+
+// Call objcopy::executeObjcopyOnBinary for \p Config and \p In. \p DataVector
+// is a holder for data. \returns Binary for copied data.
+Expected<std::unique_ptr<Binary>>
+callObjCopy(ConfigManager &Config, object::Binary &In,
+            SmallVector<char> &DataVector,
+            function_ref<bool(const Binary &File)> IsValidFormat) {
   raw_svector_ostream OutStream(DataVector);
-  Error Err = objcopy::executeObjcopyOnBinary(Config, *Obj.get(), OutStream);
-  ASSERT_FALSE(std::move(Err));
+
+  if (Error Err = objcopy::executeObjcopyOnBinary(Config, In, OutStream))
+    return std::move(Err);
 
   MemoryBufferRef Buffer(StringRef(DataVector.data(), DataVector.size()),
                          Config.Common.OutputFilename);
 
-  // Check copied file.
   Expected<std::unique_ptr<Binary>> Result = createBinary(Buffer);
+
+  // Check copied file.
+  if (!Result)
+    return Result;
+
+  if (!IsValidFormat(**Result))
+    return createError("wrong file format");
+
+  if (!(*Result)->isObject())
+    return createError("binary is not object file");
+
+  return Result;
+}
+
+// \returns true if specified \p File has a section named \p SectionName.
+bool hasSection(ObjectFile &File, StringRef SectionName) {
+  for (const object::SectionRef &Sec : File.sections()) {
+    Expected<StringRef> CurSecNameOrErr = Sec.getName();
+    if (!CurSecNameOrErr)
+      continue;
+
+    if (*CurSecNameOrErr == SectionName)
+      return true;
+  }
+
+  return false;
+}
+
+// Check that specified \p File has a section \p SectionName and its data
+// matches \p SectionData.
+void checkSectionData(ObjectFile &File, StringRef SectionName,
+                      StringRef SectionData) {
+  for (const object::SectionRef &Sec : File.sections()) {
+    Expected<StringRef> CurSecNameOrErr = Sec.getName();
+    ASSERT_THAT_EXPECTED(CurSecNameOrErr, Succeeded());
+
+    if (*CurSecNameOrErr == SectionName) {
+      Expected<StringRef> CurSectionData = Sec.getContents();
+      ASSERT_THAT_EXPECTED(CurSectionData, Succeeded());
+      EXPECT_TRUE(Sec.getSize() == SectionData.size());
+      EXPECT_TRUE(memcmp(CurSectionData->data(), SectionData.data(),
+                         SectionData.size()) == 0);
+      return;
+    }
+  }
+
+  // Section SectionName must be presented.
+  EXPECT_TRUE(false);
+}
+
+void copySimpleInMemoryFileImpl(
+    const char *YamlCreationString,
+    function_ref<bool(const Binary &File)> IsValidFormat) {
+  SCOPED_TRACE("copySimpleInMemoryFileImpl");
+
+  // Create Object file from YAML description.
+  SmallVector<char> Storage;
+  Expected<std::unique_ptr<ObjectFile>> Obj =
+      createObjectFileFromYamlDescription(YamlCreationString, Storage,
+                                          IsValidFormat);
+  ASSERT_THAT_EXPECTED(Obj, Succeeded());
+
+  ConfigManager Config;
+  Config.Common.OutputFilename = "a.out";
+
+  // Call executeObjcopyOnBinary()
+  SmallVector<char> DataVector;
+  Expected<std::unique_ptr<Binary>> Result =
+      callObjCopy(Config, *Obj.get(), DataVector, IsValidFormat);
   ASSERT_THAT_EXPECTED(Result, Succeeded());
-  ASSERT_TRUE(IsValidFormat(**Result));
 }
 
 TEST(CopySimpleInMemoryFile, COFF) {
   SCOPED_TRACE("CopySimpleInMemoryFileCOFF");
 
-  copySimpleInMemoryFileImpl(
-      R"(
---- !COFF
-header:
-  Machine:         IMAGE_FILE_MACHINE_AMD64
-  Characteristics: [  ]
-sections:
-  - Name:            .text
-    Characteristics: [  ]
-    Alignment:       4
-    SectionData:     E800000000C3C3C3
-symbols:
-...
-)",
+  copySimpleInMemoryFileImpl(SimpleFileCOFFYAML,
                              [](const Binary &File) { return File.isCOFF(); });
 }
 
 TEST(CopySimpleInMemoryFile, ELF) {
   SCOPED_TRACE("CopySimpleInMemoryFileELF");
 
-  copySimpleInMemoryFileImpl(
-      R"(
---- !ELF
-FileHeader:
-   Class:    ELFCLASS64
-   Data:     ELFDATA2LSB
-   Type:     ET_REL)",
+  copySimpleInMemoryFileImpl(SimpleFileELFYAML,
                              [](const Binary &File) { return File.isELF(); });
 }
 
 TEST(CopySimpleInMemoryFile, MachO) {
   SCOPED_TRACE("CopySimpleInMemoryFileMachO");
 
-  copySimpleInMemoryFileImpl(
-      R"(
---- !mach-o
-FileHeader:
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x80000003
-  filetype:        0x00000002
-  ncmds:           0
-  sizeofcmds:      0
-  flags:           0x00218085
-  reserved:        0x00000000
-...
-)",
+  copySimpleInMemoryFileImpl(SimpleFileMachOYAML,
                              [](const Binary &File) { return File.isMachO(); });
 }
 
 TEST(CopySimpleInMemoryFile, Wasm) {
   SCOPED_TRACE("CopySimpleInMemoryFileWasm");
 
-  copySimpleInMemoryFileImpl(
-      R"(
---- !WASM
-FileHeader:
-  Version:         0x00000001
-...
-)",
+  copySimpleInMemoryFileImpl(SimpleFileWasmYAML,
                              [](const Binary &File) { return File.isWasm(); });
 }
 
 enum Action : uint8_t { AddSection, UpdateSection };
 
 void addOrUpdateSectionToFileImpl(
     const char *YamlCreationString,
-    std::function<bool(const Binary &File)> IsValidFormat,
+    function_ref<bool(const Binary &File)> IsValidFormat,
     StringRef NewSectionName, StringRef NewSectionData, Action SectionAction) {
-  auto ErrHandler = [&](const Twine &Msg) { FAIL() << "Error: " << Msg; };
+  SCOPED_TRACE("addOrUpdateSectionToFileImpl");
 
   // Create Object file from YAML description.
   SmallVector<char> Storage;
-  std::unique_ptr<ObjectFile> Obj =
-      yaml2ObjectFile(Storage, YamlCreationString, ErrHandler);
-  ASSERT_TRUE(Obj);
-  ASSERT_TRUE(IsValidFormat(*Obj));
+  Expected<std::unique_ptr<ObjectFile>> Obj =
+      createObjectFileFromYamlDescription(YamlCreationString, Storage,
+                                          IsValidFormat);
+  ASSERT_THAT_EXPECTED(Obj, Succeeded());
 
   std::unique_ptr<MemoryBuffer> NewSectionBuffer =
       MemoryBuffer::getMemBuffer(NewSectionData, NewSectionName, false);
   std::string Name;
-  if (Obj->isMachO())
+  if ((*Obj)->isMachO())
     Name = "__TEXT," + NewSectionName.str();
   else
     Name = NewSectionName.str();
 
   ConfigManager Config;
   Config.Common.OutputFilename = "a.out";
   if (SectionAction == AddSection)
     Config.Common.AddSection.push_back({Name, std::move(NewSectionBuffer)});
   else
     Config.Common.UpdateSection.push_back({Name, std::move(NewSectionBuffer)});
 
   // Call executeObjcopyOnBinary()
   SmallVector<char> DataVector;
-  raw_svector_ostream OutStream(DataVector);
-  Error Err = objcopy::executeObjcopyOnBinary(Config, *Obj.get(), OutStream);
-  ASSERT_FALSE(std::move(Err));
-
-  MemoryBufferRef Buffer(StringRef(DataVector.data(), DataVector.size()),
-                         Config.Common.OutputFilename);
-
-  // Check copied file.
-  Expected<std::unique_ptr<Binary>> Result = createBinary(Buffer);
+  Expected<std::unique_ptr<Binary>> Result =
+      callObjCopy(Config, *Obj.get(), DataVector, IsValidFormat);
   ASSERT_THAT_EXPECTED(Result, Succeeded());
-  ASSERT_TRUE(IsValidFormat(**Result));
-  ASSERT_TRUE((*Result)->isObject());
 
   // Check that copied file has the new section.
-  bool HasNewSection = false;
-  for (const object::SectionRef &Sect :
-       static_cast<ObjectFile *>((*Result).get())->sections()) {
-    Expected<StringRef> SectNameOrErr = Sect.getName();
-    ASSERT_THAT_EXPECTED(SectNameOrErr, Succeeded());
-
-    if (*SectNameOrErr == NewSectionName) {
-      HasNewSection = true;
-      Expected<StringRef> SectionData = Sect.getContents();
-      ASSERT_THAT_EXPECTED(SectionData, Succeeded());
-      EXPECT_TRUE(Sect.getSize() == NewSectionData.size());
-      EXPECT_TRUE(memcmp(SectionData->data(), NewSectionData.data(),
-                         NewSectionData.size()) == 0);
-      break;
-    }
-  }
-  EXPECT_TRUE(HasNewSection);
+  checkSectionData(*static_cast<ObjectFile *>((*Result).get()), NewSectionName,
+                   NewSectionData);
 }
 
 TEST(AddSection, COFF) {
   SCOPED_TRACE("addSectionToFileCOFF");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !COFF
-header:
-  Machine:         IMAGE_FILE_MACHINE_AMD64
-  Characteristics: [  ]
-sections:
-  - Name:            .text
-    Characteristics: [  ]
-    Alignment:       4
-    SectionData:     E800000000C3C3C3
-symbols:
-...
-)",
-      [](const Binary &File) { return File.isCOFF(); }, ".foo", "1234",
-      AddSection);
+      SimpleFileCOFFYAML, [](const Binary &File) { return File.isCOFF(); },
+      ".foo", "1234", AddSection);
 }
 
 TEST(AddSection, ELF) {
   SCOPED_TRACE("addSectionToFileELF");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !ELF
-FileHeader:
-   Class:    ELFCLASS64
-   Data:     ELFDATA2LSB
-   Type:     ET_REL)",
-      [](const Binary &File) { return File.isELF(); }, ".foo", "1234",
-      AddSection);
+      SimpleFileELFYAML, [](const Binary &File) { return File.isELF(); },
+      ".foo", "1234", AddSection);
 }
 
 TEST(AddSection, MachO) {
   SCOPED_TRACE("addSectionToFileMachO");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !mach-o
-FileHeader:
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x80000003
-  filetype:        0x00000001
-  ncmds:           1
-  sizeofcmds:      152
-  flags:           0x00002000
-  reserved:        0x00000000
-LoadCommands:
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         152
-    segname:         __TEXT
-    vmaddr:          0
-    vmsize:          4
-    fileoff:         184
-    filesize:        4
-    maxprot:         7
-    initprot:        7
-    nsects:          1
-    flags:           0
-    Sections:
-      - sectname:        __text
-        segname:         __TEXT
-        addr:            0x0000000000000000
-        content:         'AABBCCDD'
-        size:            4
-        offset:          184
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-...
-)",
-      [](const Binary &File) { return File.isMachO(); }, "__foo", "1234",
-      AddSection);
+      SimpleFileMachOYAML, [](const Binary &File) { return File.isMachO(); },
+      "__foo", "1234", AddSection);
 }
 
 TEST(AddSection, Wasm) {
   SCOPED_TRACE("addSectionToFileWasm");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !WASM
-FileHeader:
-  Version:         0x00000001
-...
-)",
-      [](const Binary &File) { return File.isWasm(); }, ".foo", "1234",
-      AddSection);
+      SimpleFileWasmYAML, [](const Binary &File) { return File.isWasm(); },
+      ".foo", "1234", AddSection);
 }
 
 TEST(UpdateSection, COFF) {
   SCOPED_TRACE("updateSectionToFileCOFF");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !COFF
-header:
-  Machine:         IMAGE_FILE_MACHINE_AMD64
-  Characteristics: [  ]
-sections:
-  - Name:            .foo
-    Characteristics: [  ]
-    Alignment:       4
-    SectionData:     E800000000C3C3C3
-symbols:
-...
-)",
-      [](const Binary &File) { return File.isCOFF(); }, ".foo", "1234",
-      UpdateSection);
+      SimpleFileCOFFYAML, [](const Binary &File) { return File.isCOFF(); },
+      ".text", "1234", UpdateSection);
 }
 
 TEST(UpdateSection, ELF) {
   SCOPED_TRACE("updateSectionToFileELF");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !ELF
-FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-Sections:
-  - Name:            .foo
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Content:        "12345678"
-)",
-      [](const Binary &File) { return File.isELF(); }, ".foo", "1234",
-      UpdateSection);
+      SimpleFileELFYAML, [](const Binary &File) { return File.isELF(); },
+      ".text", "1234", UpdateSection);
 }
 
 TEST(UpdateSection, MachO) {
   SCOPED_TRACE("updateSectionToFileMachO");
 
   addOrUpdateSectionToFileImpl(
-      R"(
---- !mach-o
-FileHeader:
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x80000003
-  filetype:        0x00000001
-  ncmds:           1
-  sizeofcmds:      152
-  flags:           0x00002000
-  reserved:        0x00000000
-LoadCommands:
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         152
-    segname:         __TEXT
-    vmaddr:          0
-    vmsize:          4
-    fileoff:         184
-    filesize:        4
-    maxprot:         7
-    initprot:        7
-    nsects:          1
-    flags:           0
-    Sections:
-      - sectname:        __foo
-        segname:         __TEXT
-        addr:            0x0000000000000000
-        content:         'AABBCCDD'
-        size:            4
-        offset:          184
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-...
-)",
-      [](const Binary &File) { return File.isMachO(); }, "__foo", "1234",
-      UpdateSection);
+      SimpleFileMachOYAML, [](const Binary &File) { return File.isMachO(); },
+      "__text", "1234", UpdateSection);
+}
+
+void removeSectionByPatternImpl(
+    const char *YamlCreationString,
+    function_ref<bool(const Binary &File)> IsValidFormat,
+    StringRef SectionWildcard, StringRef SectionName) {
+  SCOPED_TRACE("removeSectionByPatternImpl");
+
+  // Create Object file from YAML description.
+  SmallVector<char> Storage;
+  Expected<std::unique_ptr<ObjectFile>> Obj =
+      createObjectFileFromYamlDescription(YamlCreationString, Storage,
+                                          IsValidFormat);
+  ASSERT_THAT_EXPECTED(Obj, Succeeded());
+
+  // Check that section is present.
+  EXPECT_TRUE(hasSection(**Obj, SectionName));
+
+  Expected<NameOrPattern> Pattern = objcopy::NameOrPattern::create(
+      SectionWildcard, objcopy::MatchStyle::Wildcard,
+      [](Error Err) { return Err; });
+
+  ConfigManager Config;
+  Config.Common.OutputFilename = "a.out";
+  EXPECT_THAT_ERROR(Config.Common.ToRemove.addMatcher(std::move(Pattern)),
+                    Succeeded());
+
+  SmallVector<char> DataVector;
+  Expected<std::unique_ptr<Binary>> Result =
+      callObjCopy(Config, *Obj.get(), DataVector, IsValidFormat);
+  ASSERT_THAT_EXPECTED(Result, Succeeded());
+
+  // Check that section was removed.
+  EXPECT_FALSE(
+      hasSection(*static_cast<ObjectFile *>((*Result).get()), SectionName));
+}
+
+TEST(RemoveSectionByPattern, COFF) {
+  SCOPED_TRACE("removeSectionByPatternCOFF");
+
+  removeSectionByPatternImpl(
+      SimpleFileCOFFYAML, [](const Binary &File) { return File.isCOFF(); },
+      "\\.text*", ".text");
+}
+
+TEST(RemoveSectionByPattern, ELF) {
+  SCOPED_TRACE("removeSectionByPatternELF");
+
+  removeSectionByPatternImpl(
+      SimpleFileELFYAML, [](const Binary &File) { return File.isELF(); },
+      "\\.text*", ".text");
+}
+
+TEST(RemoveSectionByPattern, MachO) {
+  SCOPED_TRACE("removeSectionByPatternMachO");
+
+  removeSectionByPatternImpl(
+      SimpleFileMachOYAML, [](const Binary &File) { return File.isMachO(); },
+      "__TEXT,__text*", "__text");
+}
+
+TEST(RemoveSectionByPattern, Wasm) {
+  SCOPED_TRACE("removeSectionByPatternWasm");
+
+  removeSectionByPatternImpl(
+      SimpleFileWasmYAML, [](const Binary &File) { return File.isWasm(); },
+      "text*", "text");
 }