[llvm-objcopy][MachO] Implement -Ibinary

[seiya]

Summary

This patch implements -Ibinary for MachO (64bit only for now).

[seiya]

I'll add another patch to isolate changes to CopyConfig.

[seiya]

• No such file or directory -> {{[Nn]}}o such file or directory

[seiya]

Moved changes to CopyConfig to D66449.

[seiya]

Added a newline at the end of file.

[jhenderson]

llvm/test/tools/llvm-objcopy/MachO/binary-input.test

1

If I'm not mistaken, it should be Mach-O here rather than MachO.

2

contains the input...

llvm/tools/llvm-objcopy/MachO/MachOReader.h

9

You shouldn't need the relative path. You should just be able to do "CopyConfig.h". If that doesn't work, then there's something wrong with the include directories, I think. This might point to a bigger flaw in llvm-objcopy's include paths.

[seiya]

Update CommandGuide.

[seiya]

Addressed review comments.

[jhenderson]

Okay, no more comments from me. Somebody with more Mach-O experience should look at the rest.

[alexander-shaposhnikov]

I'll take a closer look at this diff this week, sorry about the delay

[rupprecht]

LGTM

llvm/test/tools/llvm-objcopy/MachO/binary-input.test

2

llvm-objcopy

5

Per the other patch, these should use -B i386:x86-64 as the main supported config

41

I believe you should be able to check for .input to appear in these strings as _input too, e.g. __binary_{{[_a-zA-Z0-9]*}}_input_size

[seiya]

Addressed review comments and added test for arm64.

[seiya]

llvm/test/tools/llvm-objcopy/MachO/binary-input.test

20

Note that GNU objcopy sets MH_MAGIC instead of MH_MAGIC64 for aarch64:

$ gobjcopy -I binary -B aarch64 -O mach-o-arm64 foo.txt binary.arm64.o

$ llvm-readobj binary.arm64.o                                         
File: binary.arm64.o
Format: Mach-O 32-bit unknown         <- should be "Mach-O arm64"!
Arch: aarch64
AddressSize: 32bit

$ otool -h binary.arm64.o   
Mach header
      magic cputype cpusubtype  caps    filetype ncmds  ...
 0xfeedface 16777228          0  0x00           1     3    ...

I have no experience with aarch64 MachO objects, but AFAIK the magic should be MH_MAGIC64 (example). I believe it's a bug in GNU objcopy...

llvm/test/tools/llvm-objcopy/MachO/binary-input.test

+# Show that if -I binary is given, llvm-objopy creates a MachO object which
+# contains input file contents.
+
+RUN: not llvm-objcopy -Ibinary -B x86-64 -Omach-o-x86-64 %t.nonexistent %t.o.nonexistent 2>&1 \
+RUN:   | FileCheck %s -DINPUT=%t.nonexistent --check-prefix=NONEXSITENT-FILE
+NONEXSITENT-FILE: error: '[[INPUT]]': {{[Nn]}}o such file or directory
+
+RUN: echo -n abcdefg > %t.input
+RUN: llvm-objcopy -Ibinary -B x86-64 -Omach-o-x86-64 %t.input %t.o
+RUN: llvm-readobj --sections --section-data --symbols --macho-segment --macho-dysymtab %t.o \
+RUN:   | FileCheck %s
+
+CHECK:       Format: Mach-O 64-bit x86-64
+CHECK-NEXT:  Arch: x86_64
+CHECK-NEXT:  AddressSize: 64bit
+CHECK-NEXT:  Sections [
+CHECK-NEXT:    Section {
+CHECK-NEXT:      Index: 0
+CHECK-NEXT:      Name: __data (5F 5F 64 61 74 61 00 00 00 00 00 00 00 00 00 00)
+CHECK-NEXT:      Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
+CHECK-NEXT:      Address: 0x0
+CHECK-NEXT:      Size: 0x7
+CHECK-NEXT:      Offset: 288
+CHECK-NEXT:      Alignment: 0
+CHECK-NEXT:      RelocationOffset: 0x0
+CHECK-NEXT:      RelocationCount: 0
+CHECK-NEXT:      Type: Regular (0x0)
+CHECK-NEXT:      Attributes [ (0x0)
+CHECK-NEXT:      ]
+CHECK-NEXT:      Reserved1: 0x0
+CHECK-NEXT:      Reserved2: 0x0
+CHECK-NEXT:      Reserved3: 0x0
+CHECK-NEXT:      SectionData (
+CHECK-NEXT:        0000: 61626364 656667 |abcdefg|
+CHECK-NEXT:      )
+CHECK-NEXT:    }
+CHECK-NEXT:  ]
+CHECK-NEXT:  Symbols [
+CHECK-NEXT:    Symbol {
+CHECK-NEXT:      Name: __binary_{{[_a-zA-Z0-9]*}}_size
+CHECK-NEXT:      Extern
+CHECK-NEXT:      Type: Abs (0x2)
+CHECK-NEXT:      Section: (0x0)
+CHECK-NEXT:      RefType: ReferenceFlagDefined (0x2)
+CHECK-NEXT:      Flags [ (0x0)
+CHECK-NEXT:      ]
+CHECK-NEXT:      Value: 0x7
+CHECK-NEXT:    }
+CHECK-NEXT:    Symbol {
+CHECK-NEXT:      Name: __binary_{{[_a-zA-Z0-9]*}}_start
+CHECK-NEXT:      Extern
+CHECK-NEXT:      Type: Section (0xE)
+CHECK-NEXT:      Section: __data (0x1)
+CHECK-NEXT:      RefType: ReferenceFlagDefined (0x2)
+CHECK-NEXT:      Flags [ (0x0)
+CHECK-NEXT:      ]
+CHECK-NEXT:      Value: 0x0
+CHECK-NEXT:    }
+CHECK-NEXT:    Symbol {
+CHECK-NEXT:      Name: __binary_{{[_a-zA-Z0-9]*}}_end
+CHECK-NEXT:      Extern
+CHECK-NEXT:      Type: Section (0xE)
+CHECK-NEXT:      Section: __data (0x1)
+CHECK-NEXT:      RefType: ReferenceFlagDefined (0x2)
+CHECK-NEXT:      Flags [ (0x0)
+CHECK-NEXT:      ]
+CHECK-NEXT:      Value: 0x7
+CHECK-NEXT:    }
+CHECK-NEXT:  ]
+CHECK-NEXT:  Segment {
+CHECK-NEXT:    Cmd: LC_SEGMENT_64
+CHECK-NEXT:    Name:
+CHECK-NEXT:    Size: 152
+CHECK-NEXT:    vmaddr: 0x0
+CHECK-NEXT:    vmsize: 0x7
+CHECK-NEXT:    fileoff: 288
+CHECK-NEXT:    filesize: 7
+CHECK-NEXT:    maxprot: rwx
+CHECK-NEXT:    initprot: rwx
+CHECK-NEXT:    nsects: 1
+CHECK-NEXT:    flags: 0x0
+CHECK-NEXT:  }
+CHECK-NEXT:  Dysymtab {
+CHECK-NEXT:    ilocalsym: 0
+CHECK-NEXT:    nlocalsym: 0
+CHECK-NEXT:    iextdefsym: 0
+CHECK-NEXT:    nextdefsym: 3
+CHECK-NEXT:    iundefsym: 3
+CHECK-NEXT:    nundefsym: 0
+CHECK-NEXT:    tocoff: 0
+CHECK-NEXT:    ntoc: 0
+CHECK-NEXT:    modtaboff: 0
+CHECK-NEXT:    nmodtab: 0
+CHECK-NEXT:    extrefsymoff: 0
+CHECK-NEXT:    nextrefsyms: 0
+CHECK-NEXT:    indirectsymoff: 0
+CHECK-NEXT:    nindirectsyms: 0
+CHECK-NEXT:    extreloff: 0
+CHECK-NEXT:    nextrel: 0
+CHECK-NEXT:    locreloff: 0
+CHECK-NEXT:    nlocrel: 0
+CHECK-NEXT:  }

llvm/tools/llvm-objcopy/MachO/MachOObjcopy.h

 //===- MachOObjcopy.h -------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OBJCOPY_MACHOOBJCOPY_H
 #define LLVM_TOOLS_OBJCOPY_MACHOOBJCOPY_H
 
+#include "llvm/Support/MemoryBuffer.h"
+
 namespace llvm {
 class Error;
+class MemoryBuffer;
 
 namespace object {
 class MachOObjectFile;
 class MachOUniversalBinary;
 } // end namespace object
 
 namespace objcopy {
 struct CopyConfig;
 class Buffer;
 
 namespace macho {
+Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
+                                Buffer &Out);
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::MachOObjectFile &In, Buffer &Out);
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_MACHOOBJCOPY_H

llvm/tools/llvm-objcopy/MachO/MachOObjcopy.cpp

static Error handleArgs(const CopyConfig &Config, Object &Obj) {
   if (Config.StripAll)
     for (LoadCommand &LC : Obj.LoadCommands)
       for (Section &Sec : LC.Sections)
         Sec.Relocations.clear();
 
   return Error::success();
 }
 
+Error writeOutput(Object &O, Buffer &Out, bool Is64Bit, bool IsLittleEndian) {
+  // TODO: Support 16KB pages which are employed in iOS arm64 binaries:
+  //       https://github.com/llvm/llvm-project/commit/1bebb2832ee312d3b0316dacff457a7a29435edb
+  const uint64_t PageSize = 4096;
+
+  MachOWriter Writer(O, Is64Bit, IsLittleEndian, PageSize, Out);
+  if (auto E = Writer.finalize())
+    return E;
+  return Writer.write();
+}
+
+Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
+                                Buffer &Out) {
+  const MachineInfo &MI = Config.BinaryArch;
+  BinaryReader Reader(MI, In);
+  std::unique_ptr<Object> O = Reader.create();
+
+  if (Error E = handleArgs(Config, *O))
+    return createFileError(Config.InputFilename, std::move(E));
+
+  return writeOutput(*O, Out, MI.Is64Bit, MI.IsLittleEndian);
+}
+
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::MachOObjectFile &In, Buffer &Out) {
   MachOReader Reader(In);
   std::unique_ptr<Object> O = Reader.create();
   if (!O)
     return createFileError(
         Config.InputFilename,
         createStringError(object_error::parse_failed,
                           "unable to deserialize MachO object"));
 
   if (Error E = handleArgs(Config, *O))
     return createFileError(Config.InputFilename, std::move(E));
 
-  // TODO: Support 16KB pages which are employed in iOS arm64 binaries:
-  //       https://github.com/llvm/llvm-project/commit/1bebb2832ee312d3b0316dacff457a7a29435edb
-  const uint64_t PageSize = 4096;
-
-  MachOWriter Writer(*O, In.is64Bit(), In.isLittleEndian(), PageSize, Out);
-  if (auto E = Writer.finalize())
-    return E;
-  return Writer.write();
+  return writeOutput(*O, Out, In.is64Bit(), In.isLittleEndian());
 }
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOReader.h

 //===- MachOReader.h --------------------------------------------*- C++ -*-===//
 //
 // 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 "MachOObjcopy.h"
 #include "Object.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/MachO.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 
 namespace llvm {
 namespace objcopy {
 namespace macho {
 
 // The hierarchy of readers is responsible for parsing different inputs:
 // raw binaries and regular MachO object files.
class MachOReader : public Reader {
   void readIndirectSymbolTable(Object &O) const;
 
 public:
   explicit MachOReader(const object::MachOObjectFile &Obj) : MachOObj(Obj) {}
 
   std::unique_ptr<Object> create() const override;
 };
 
+class BinaryReader : public Reader {
+  const MachineInfo &MI;
+  MemoryBuffer &Input;
+  std::unique_ptr<WritableMemoryBuffer> SectionContent;
+
+public:
+  BinaryReader(const MachineInfo &MI, MemoryBuffer &Input)
+      : MI(MI), Input(Input) {
+    SectionContent =
+        WritableMemoryBuffer::getNewUninitMemBuffer(Input.getBufferSize());
+  }
+  std::unique_ptr<Object> create() const override;
+};
+
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

#include "llvm/BinaryFormat/MachO.def"
     O.LoadCommands.push_back(std::move(LC));
   }
 }
 
 template <typename nlist_t>
 SymbolEntry constructSymbolEntry(StringRef StrTable, const nlist_t &nlist) {
   assert(nlist.n_strx < StrTable.size() &&
          "n_strx exceeds the size of the string table");
-  SymbolEntry SE;
-  SE.Name = StringRef(StrTable.data() + nlist.n_strx).str();
-  SE.n_type = nlist.n_type;
-  SE.n_sect = nlist.n_sect;
-  SE.n_desc = nlist.n_desc;
-  SE.n_value = nlist.n_value;
-  return SE;
+  return SymbolEntry(StringRef(StrTable.data() + nlist.n_strx).str(),
+                     nlist.n_type, nlist.n_sect, nlist.n_desc, nlist.n_value);
 }
 
 void MachOReader::readSymbolTable(Object &O) const {
   StringRef StrTable = MachOObj.getStringTableData();
   for (auto Symbol : MachOObj.symbols()) {
     SymbolEntry SE =
         (MachOObj.is64Bit()
              ? constructSymbolEntry(
std::unique_ptr<Object> MachOReader::create() const {
   readLazyBindInfo(*Obj);
   readExportInfo(*Obj);
   readDataInCodeData(*Obj);
   readFunctionStartsData(*Obj);
   readIndirectSymbolTable(*Obj);
   return Obj;
 }
 
+std::unique_ptr<Object> BinaryReader::create() const {
+  assert(MI.Is64Bit && "32-bit object is not yet supported");
+  auto Obj = std::make_unique<Object>();
+
+  size_t HeaderSize =
+      MI.Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
+  size_t SegLoadCommandSize =
+      MI.Is64Bit
+          ? (sizeof(MachO::segment_command_64) + sizeof(MachO::section_64))
+          : (sizeof(MachO::segment_command) + sizeof(MachO::section));
+  size_t SizeOfCmds = SegLoadCommandSize + sizeof(MachO::symtab_command) +
+                      sizeof(MachO::dysymtab_command);
+  uint64_t SegOffset = HeaderSize + SizeOfCmds;
+  Obj->Header.Magic = MI.Is64Bit ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC;
+  Obj->Header.CPUType = MI.MachOCPUType;
+  Obj->Header.CPUSubType = MI.MachOCPUSubType;
+  Obj->Header.FileType = MachO::MH_OBJECT;
+  Obj->Header.NCmds = 1;
+  Obj->Header.Flags = 0;
+  Obj->Header.SizeOfCmds = SizeOfCmds;
+
+  LoadCommand &LC = Obj->addSegment("");
+  MachO::segment_command_64 &Seg = LC.MachOLoadCommand.segment_command_64_data;
+  Seg.vmsize = SectionContent->getBufferSize();
+  Seg.fileoff = SegOffset;
+  Seg.filesize = SectionContent->getBufferSize();
+  Seg.maxprot =
+      MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
+  Seg.initprot =
+      MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
+
+  Section Sec("__DATA", "__data");
+  Sec.Size = SectionContent->getBufferSize();
+  Sec.Offset = SegOffset;
+  memcpy(SectionContent->getBufferStart(), Input.getBufferStart(),
+         Input.getBufferSize());
+  Sec.setOwnedContentData(ArrayRef<uint8_t>(
+      reinterpret_cast<const uint8_t *>(SectionContent->getBufferStart()),
+      SectionContent->getBufferSize()));
+  LC.Sections.push_back(Sec);
+
+  LoadCommand DySymTab;
+  MachO::dysymtab_command &DySymTabData =
+      DySymTab.MachOLoadCommand.dysymtab_command_data;
+  memset(&DySymTabData, 0, sizeof(DySymTabData));
+  DySymTabData.cmd = MachO::LC_DYSYMTAB;
+  DySymTabData.cmdsize = sizeof(MachO::dysymtab_command);
+
+  LoadCommand SymTab;
+  MachO::symtab_command &SymTabData =
+      SymTab.MachOLoadCommand.symtab_command_data;
+  memset(&SymTabData, 0, sizeof(SymTabData));
+  SymTabData.cmd = MachO::LC_SYMTAB;
+  SymTabData.cmdsize = sizeof(MachO::symtab_command);
+
+  Obj->LoadCommands.push_back(DySymTab);
+  Obj->DySymTabCommandIndex = Obj->LoadCommands.size() - 1;
+  Obj->LoadCommands.push_back(SymTab);
+  Obj->SymTabCommandIndex = Obj->LoadCommands.size() - 1;
+
+  std::string SanitizedFilename = Input.getBufferIdentifier().str();
+  // Replace characters that are not valid for symbol name.
+  std::replace_if(
+      std::begin(SanitizedFilename), std::end(SanitizedFilename),
+      [](char C) { return !isalnum(C); }, '_');
+  Twine Prefix = Twine("__binary_") + SanitizedFilename;
+
+  Obj->SymTable.addSymbol(Prefix + "_size", MachO::N_ABS | MachO::N_EXT, 0,
+                          MachO::REFERENCE_FLAG_DEFINED, Input.getBufferSize());
+  Obj->SymTable.addSymbol(Prefix + "_start", MachO::N_SECT | MachO::N_EXT, 1,
+                          MachO::REFERENCE_FLAG_DEFINED, 0);
+  Obj->SymTable.addSymbol(Prefix + "_end", MachO::N_SECT | MachO::N_EXT, 1,
+                          MachO::REFERENCE_FLAG_DEFINED,
+                          SectionContent->getBufferSize());
+
+  return Obj;
+}
+
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOWriter.cpp

case MachO::LC_SEGMENT_64:
       Begin += sizeof(MachO::segment_command_64);
 
       for (const auto &Sec : LC.Sections)
         writeSectionInLoadCommand<MachO::section_64>(Sec, Begin);
       continue;
     }
 
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
-  case MachO::LCName:                                                          \
+  case MachO::LCName: {                                                        \
     assert(sizeof(MachO::LCStruct) + LC.Payload.size() ==                      \
            MLC.load_command_data.cmdsize);                                     \
     if (IsLittleEndian != sys::IsLittleEndianHost)                             \
       MachO::swapStruct(MLC.LCStruct##_data);                                  \
     memcpy(Begin, &MLC.LCStruct##_data, sizeof(MachO::LCStruct));              \
     Begin += sizeof(MachO::LCStruct);                                          \
-    memcpy(Begin, LC.Payload.data(), LC.Payload.size());                       \
+    /* Call memcpy only if it's not empty due to a nonnull attribute of */     \
+    /* memcpy's 2nd argument. */                                               \
+    if (LC.Payload.size() > 0)                                                 \
+      memcpy(Begin, LC.Payload.data(), LC.Payload.size());                     \
     Begin += LC.Payload.size();                                                \
-    break;
+    break;                                                                     \
+  }
 
     // Copy the load command as it is.
     switch (MLC.load_command_data.cmd) {
-    default:
+    default: {
       assert(sizeof(MachO::load_command) + LC.Payload.size() ==
              MLC.load_command_data.cmdsize);
       if (IsLittleEndian != sys::IsLittleEndianHost)
         MachO::swapStruct(MLC.load_command_data);
       memcpy(Begin, &MLC.load_command_data, sizeof(MachO::load_command));
       Begin += sizeof(MachO::load_command);
+      if (LC.Payload.size() > 0)
         memcpy(Begin, LC.Payload.data(), LC.Payload.size());
       Begin += LC.Payload.size();
       break;
+    }
 #include "llvm/BinaryFormat/MachO.def"
     }
   }
 }
 
 template <typename StructType>
 void MachOWriter::writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out) {
   StructType Temp;

llvm/tools/llvm-objcopy/MachO/Object.h

struct SymbolEntry {
   std::string Name;
   bool Referenced = false;
   uint32_t Index;
   uint8_t n_type;
   uint8_t n_sect;
   uint16_t n_desc;
   uint64_t n_value;
 
+  SymbolEntry(std::string Name, uint8_t Type, uint8_t Sect, uint16_t Desc,
+              uint64_t Value)
+      : Name(Name), n_type(Type), n_sect(Sect), n_desc(Desc), n_value(Value) {}
+
   bool isExternalSymbol() const {
     return n_type & ((MachO::N_EXT | MachO::N_PEXT));
   }
 
   bool isLocalSymbol() const { return !isExternalSymbol(); }
 
   bool isUndefinedSymbol() const {
     return (n_type & MachO::N_TYPE) == MachO::N_UNDF;
   }
 };
 
 /// The location of the symbol table inside the binary is described by LC_SYMTAB
 /// load command.
 struct SymbolTable {
   std::vector<std::unique_ptr<SymbolEntry>> Symbols;
 
   const SymbolEntry *getSymbolByIndex(uint32_t Index) const;
   SymbolEntry *getSymbolByIndex(uint32_t Index);
   void removeSymbols(
       function_ref<bool(const std::unique_ptr<SymbolEntry> &)> ToRemove);
+  void addSymbol(Twine Name, uint8_t Type, uint8_t Sect, uint16_t Desc,
+                 uint64_t Value);
 };
 
 struct IndirectSymbolEntry {
   uint32_t OriginalIndex;
   /// The Symbol referenced by this entry. It's None if the index is
   /// INDIRECT_SYMBOL_LOCAL or INDIRECT_SYMBOL_ABS.
   Optional<SymbolEntry *> Symbol;
 

llvm/tools/llvm-objcopy/MachO/Object.cpp

 
 void SymbolTable::removeSymbols(
     function_ref<bool(const std::unique_ptr<SymbolEntry> &)> ToRemove) {
   Symbols.erase(
       std::remove_if(std::begin(Symbols), std::end(Symbols), ToRemove),
       std::end(Symbols));
 }
 
+void SymbolTable::addSymbol(Twine Name, uint8_t Type, uint8_t Sect,
+                            uint16_t Desc, uint64_t Value) {
+  Symbols.push_back(
+      std::make_unique<SymbolEntry>(Name.str(), Type, Sect, Desc, Value));
+}
+
 void Object::removeSections(function_ref<bool(const Section &)> ToRemove) {
   for (LoadCommand &LC : LoadCommands)
     LC.Sections.erase(std::remove_if(std::begin(LC.Sections),
                                      std::end(LC.Sections), ToRemove),
                       std::end(LC.Sections));
 }
 
 LoadCommand &Object::addSegment(StringRef SegName) {

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

static Error executeObjcopyOnIHex(const CopyConfig &Config, MemoryBuffer &In,
   return elf::executeObjcopyOnIHex(Config, In, Out);
 }
 
 /// The function executeObjcopyOnRawBinary does the dispatch based on the format
 /// of the output specified by the command line options.
 static Error executeObjcopyOnRawBinary(const CopyConfig &Config,
                                        MemoryBuffer &In, Buffer &Out) {
   switch (Config.OutputFormat) {
+  case FileFormat::MachO:
+    return macho::executeObjcopyOnRawBinary(Config, In, Out);
   case FileFormat::ELF:
   // FIXME: Currently, we call elf::executeObjcopyOnRawBinary even if the
   // output format is binary/ihex or it's not given. This behavior differs from
   // GNU objcopy. See https://bugs.llvm.org/show_bug.cgi?id=42171 for details.
   case FileFormat::Binary:
   case FileFormat::IHex:
   case FileFormat::Unspecified:
     return elf::executeObjcopyOnRawBinary(Config, In, Out);