[llvm-objcopy] Recognize the output file format other than ELF

[seiya]

Summary

Currently, llvm-objcopy doesn't recognize the output file format given by the -O option and implicitly calls
elf::executeObjcopyOnRawBinary if the input is binary.

This patches changes the type of Config.InputFormat and Config.OutputFormat to an enum so that
we can call executeObjcopyOnRawBinary function for other output file formats like MachO in the future.

In addition to this, this patch adds -O option into tests some tests because it seems that GNU objcopy simply
copies the input file if -O is not specified, that is, if you run objcopy -Ibinary foo.txt bar, the output file "bar" is
identical "foo.txt", not an ELF object file.

Furthermore, this patch adds "elf32-sparc" format to fix the "-B sparc" test in binary-input-arch.test.

[jhenderson]

@seiya, it looks like what you've observed in the tests is https://bugs.llvm.org/show_bug.cgi?id=42171. Can you confirm, and if so update the bug accordingly?

I feel like there might be three different patches here, rather than one big one. The first one is the bug fix (with corresponding test changes), the second is the sparc format issue, and the third is the work your title suggests this patch should be doing (i.e. changing the types). Please could you split it up, as it will make it easier to review each change separately.

[seiya]

In D63184#1539487, @jhenderson wrote:

@seiya, it looks like what you've observed in the tests is https://bugs.llvm.org/show_bug.cgi?id=42171. Can you confirm, and if so update the bug accordingly?

I feel like there might be three different patches here, rather than one big one. The first one is the bug fix (with corresponding test changes), the second is the sparc format issue, and the third is the work your title suggests this patch should be doing (i.e. changing the types). Please could you split it up, as it will make it easier to review each change separately.

Thank you. I missed that. That bug is what I want to fix this patch. I'll split this into separate patches.

[seiya]

Splitted into separate patches:

• https://reviews.llvm.org/D63238
• https://reviews.llvm.org/D63239

[jhenderson]

For what it's worth, the usual thing to do is to leave the "core" of these sort of changes in the original patch, and create one or more new patches for the other part(s).

llvm/test/tools/llvm-objcopy/ELF/binary-input-and-output.test

 # RUN: echo abcd > %t.txt
 
 # Preserve input to verify it is not modified
 # RUN: cp %t.txt %t-copy.txt
 
 # -I binary -O binary preserves payload through in-memory representation
 # RUN: llvm-objcopy -I binary -B i386:x86-64 -O binary %t.txt %t.2.txt
 # RUN: cmp %t.txt %t.2.txt
 # RUN: cmp %t.txt %t-copy.txt
 
 # -I binary -O binary preserves payload through an intermediate object file
-# RUN: llvm-objcopy -I binary -B i386:x86-64 %t.txt %t.o
+# RUN: llvm-objcopy -I binary -B x86-64 -O elf64-x86-64 %t.txt %t.o
 # RUN: llvm-objcopy -O binary %t.o %t.3.txt
 # RUN: cmp %t.txt %t.3.txt
 # RUN: cmp %t.txt %t-copy.txt

llvm/test/tools/llvm-objcopy/ELF/binary-input-arch.test

 # RUN: echo abcd > %t.txt
 
-# RUN: llvm-objcopy -I binary -B aarch64 %t.txt %t.aarch64.o
+# RUN: llvm-objcopy -I binary -B aarch64 -O elf64-aarch64 %t.txt %t.aarch64.o
 # RUN: llvm-readobj --file-headers %t.aarch64.o | FileCheck %s --check-prefixes=CHECK,LE,AARCH64,64
 
-# RUN: llvm-objcopy -I binary -B arm %t.txt %t.arm.o
+# RUN: llvm-objcopy -I binary -B arm -O elf32-littlearm %t.txt %t.arm.o
 # RUN: llvm-readobj --file-headers %t.arm.o | FileCheck %s --check-prefixes=CHECK,LE,ARM,32
 
-# RUN: llvm-objcopy -I binary -B i386 %t.txt %t.i386.o
+# RUN: llvm-objcopy -I binary -B i386 -O elf32-i386 %t.txt %t.i386.o
 # RUN: llvm-readobj --file-headers %t.i386.o | FileCheck %s --check-prefixes=CHECK,LE,I386,32
 
-# RUN: llvm-objcopy -I binary -B i386:x86-64 %t.txt %t.i386_x86-64.o
+# RUN: llvm-objcopy -I binary -B i386:x86-64 -O elf64-x86-64 %t.txt %t.i386_x86-64.o
 # RUN: llvm-readobj --file-headers %t.i386_x86-64.o | FileCheck %s --check-prefixes=CHECK,LE,X86-64,64
 
-# RUN: llvm-objcopy -I binary -B mips %t.txt %t.mips.o
+# RUN: llvm-objcopy -I binary -B mips -O elf32-bigmips %t.txt %t.mips.o
 # RUN: llvm-readobj --file-headers %t.mips.o | FileCheck %s --check-prefixes=CHECK,BE,MIPS,32
 
-# RUN: llvm-objcopy -I binary -B powerpc:common64 %t.txt %t.powerpc_common64.o
+# RUN: llvm-objcopy -I binary -B powerpc:common64 -O elf64-powerpcle %t.txt %t.powerpc_common64.o
 # RUN: llvm-readobj --file-headers %t.powerpc_common64.o | FileCheck %s --check-prefixes=CHECK,LE,PPC,64
 
-# RUN: llvm-objcopy -I binary -B riscv:rv32 %t.txt %t.rv32.o
+# RUN: llvm-objcopy -I binary -B riscv:rv32 -O elf32-littleriscv %t.txt %t.rv32.o
 # RUN: llvm-readobj --file-headers %t.rv32.o | FileCheck %s --check-prefixes=CHECK,LE,RISCV32,32
 
-# RUN: llvm-objcopy -I binary -B riscv:rv64 %t.txt %t.rv64.o
+# RUN: llvm-objcopy -I binary -B riscv:rv64 -O elf64-littleriscv %t.txt %t.rv64.o
 # RUN: llvm-readobj --file-headers %t.rv64.o | FileCheck %s --check-prefixes=CHECK,LE,RISCV64,64
 
-# RUN: llvm-objcopy -I binary -B sparc %t.txt %t.sparc.o
+# RUN: llvm-objcopy -I binary -B sparc -O elf32-sparc %t.txt %t.sparc.o
 # RUN: llvm-readobj --file-headers %t.sparc.o | FileCheck %s --check-prefixes=CHECK,LE,SPARC,32
 
-# RUN: llvm-objcopy -I binary -B x86-64 %t.txt %t.x86-64.o
+# RUN: llvm-objcopy -I binary -B x86-64 -O elf64-x86-64 %t.txt %t.x86-64.o
 # RUN: llvm-readobj --file-headers %t.x86-64.o | FileCheck %s --check-prefixes=CHECK,LE,X86-64,64
 
 # CHECK: Format:
 # 32-SAME:      ELF32-
 # 64-SAME:      ELF64-
 # AARCH64-SAME: aarch64-little
 # ARM-SAME:     arm-little
 # I386-SAME:    i386

llvm/test/tools/llvm-objcopy/ELF/binary-input-error.test

 # RUN: echo abcd > %t.txt
 
 # RUN: not llvm-objcopy -I binary %t.txt %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-BINARY-ARCH
 
 # RUN: not llvm-objcopy -I binary -B xyz %t.txt %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=BAD-BINARY-ARCH
 
+# RUN: not llvm-objcopy -I binary -B i386 %t.txt %t.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=MISSING-OUTPUT-FORMAT
+
 # MISSING-BINARY-ARCH: Specified binary input without specifiying an architecture
 # BAD-BINARY-ARCH: Invalid architecture: 'xyz'
+
+# MISSING-OUTPUT-FORMAT: specified binary input without specifying the output file format
 No newline at end of file

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

 # RUN: echo -n abcd > %t.x-txt
 # Preserve input to verify it is not modified
 # RUN: cp %t.x-txt %t-copy.txt
-# RUN: llvm-objcopy -I binary -B i386:x86-64 %t.x-txt %t.o
+# RUN: llvm-objcopy -I binary -B i386:x86-64 -O elf64-x86-64 %t.x-txt %t.o
 # RUN: llvm-readobj --sections --symbols %t.o | FileCheck %s
 # RUN: cmp %t.x-txt %t-copy.txt
 
 # CHECK:      Sections [
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 0
 # CHECK-NEXT:     Name:  (0)
 # CHECK-NEXT:     Type: SHT_NULL (0x0)

llvm/tools/llvm-objcopy/CopyConfig.h

 #include "llvm/Support/Regex.h"
 // Necessary for llvm::DebugCompressionType::None
 #include "llvm/Target/TargetOptions.h"
 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 
+enum class FileFormat {
+  Unspecified,
+  ELF,
+  Binary,
+  IHex,
+};
+
 // This type keeps track of the machine info for various architectures. This
 // lets us map architecture names to ELF types and the e_machine value of the
 // ELF file.
 struct MachineInfo {
   MachineInfo(uint16_t EM, uint8_t ABI, bool Is64, bool IsLittle)
       : EMachine(EM), OSABI(ABI), Is64Bit(Is64), IsLittleEndian(IsLittle) {}
-  // Alternative constructor that defaults to NONE for OSABI.
-  MachineInfo(uint16_t EM, bool Is64, bool IsLittle)
-      : MachineInfo(EM, ELF::ELFOSABI_NONE, Is64, IsLittle) {}
   // Default constructor for unset fields.
   MachineInfo() : MachineInfo(0, 0, false, false) {}
+
   uint16_t EMachine;
   uint8_t OSABI;
   bool Is64Bit;
   bool IsLittleEndian;
 };
 
 // Flags set by --set-section-flags or --rename-section. Interpretation of these
 // is format-specific and not all flags are meaningful for all object file
struct NewSymbolInfo {
   uint8_t Bind = ELF::STB_GLOBAL;
   uint8_t Visibility = ELF::STV_DEFAULT;
 };
 
 // Configuration for copying/stripping a single file.
 struct CopyConfig {
   // Main input/output options
   StringRef InputFilename;
-  StringRef InputFormat;
+  FileFormat InputFormat;
   StringRef OutputFilename;
-  StringRef OutputFormat;
+  FileFormat 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;

llvm/tools/llvm-objcopy/CopyConfig.cpp

if (!UnsupportedFlags.empty())
     return createStringError(errc::invalid_argument,
                              "unsupported flag%s for --add-symbol: '%s'",
                              UnsupportedFlags.size() > 1 ? "s" : "",
                              join(UnsupportedFlags, "', '").c_str());
   return SI;
 }
 
 static const StringMap<MachineInfo> ArchMap{
-    // Name, {EMachine, 64bit, LittleEndian}
-    {"aarch64", {ELF::EM_AARCH64, true, true}},
-    {"arm", {ELF::EM_ARM, false, true}},
-    {"i386", {ELF::EM_386, false, true}},
-    {"i386:x86-64", {ELF::EM_X86_64, true, true}},
-    {"mips", {ELF::EM_MIPS, false, false}},
-    {"powerpc:common64", {ELF::EM_PPC64, true, true}},
-    {"riscv:rv32", {ELF::EM_RISCV, false, true}},
-    {"riscv:rv64", {ELF::EM_RISCV, true, true}},
-    {"sparc", {ELF::EM_SPARC, false, true}},
-    {"x86-64", {ELF::EM_X86_64, true, true}},
+    // Name, {EMachine, OSABI, MachOCPUType, MachOCPUSubType, 64bit,
+    // LittleEndian}
+    {"aarch64", {ELF::EM_AARCH64, ELF::ELFOSABI_NONE, true, true}},
+    {"arm", {ELF::EM_ARM, ELF::ELFOSABI_NONE, false, true}},
+    {"i386", {ELF::EM_386, ELF::ELFOSABI_NONE, false, true}},
+    {"i386:x86-64", {ELF::EM_X86_64, ELF::ELFOSABI_NONE, true, true}},
+    {"mips", {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, false}},
+    {"powerpc:common64", {ELF::EM_PPC64, ELF::ELFOSABI_NONE, true, true}},
+    {"riscv:rv32", {ELF::EM_RISCV, ELF::ELFOSABI_NONE, false, true}},
+    {"riscv:rv64", {ELF::EM_RISCV, ELF::ELFOSABI_NONE, true, true}},
+    {"sparc", {ELF::EM_SPARC, ELF::ELFOSABI_NONE, false, true}},
+    {"x86-64", {ELF::EM_X86_64, ELF::ELFOSABI_NONE, true, true}},
 };
 
-static Expected<const MachineInfo &> getMachineInfo(StringRef Arch) {
+static Expected<const MachineInfo &> getMachineInfoByArchName(StringRef Arch) {
   auto Iter = ArchMap.find(Arch);
   if (Iter == std::end(ArchMap))
     return createStringError(errc::invalid_argument,
                              "Invalid architecture: '%s'", Arch.str().c_str());
   return Iter->getValue();
 }
 
 // FIXME: consolidate with the bfd parsing used by lld.
-static const StringMap<MachineInfo> OutputFormatMap{
-    // Name, {EMachine, 64bit, LittleEndian}
+static const StringMap<std::pair<FileFormat, MachineInfo>> FileFormatMap{
+    // Name, {FileFormat, {EMachine, OSABI, MachOCPUType, MachOCPUSubType,
+    // 64bit, LittleEndian}}
     // x86
-    {"elf32-i386", {ELF::EM_386, false, true}},
-    {"elf32-x86-64", {ELF::EM_X86_64, false, true}},
-    {"elf64-x86-64", {ELF::EM_X86_64, true, true}},
+    {"elf32-i386",
+     {FileFormat::ELF, {ELF::EM_386, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf32-x86-64",
+     {FileFormat::ELF, {ELF::EM_X86_64, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf64-x86-64",
+     {FileFormat::ELF, {ELF::EM_X86_64, ELF::ELFOSABI_NONE, true, true}}},
     // Intel MCU
-    {"elf32-iamcu", {ELF::EM_IAMCU, false, true}},
+    {"elf32-iamcu",
+     {FileFormat::ELF, {ELF::EM_IAMCU, ELF::ELFOSABI_NONE, false, true}}},
     // ARM
-    {"elf32-littlearm", {ELF::EM_ARM, false, true}},
+    {"elf32-littlearm",
+     {FileFormat::ELF, {ELF::EM_ARM, ELF::ELFOSABI_NONE, false, true}}},
     // ARM AArch64
-    {"elf64-aarch64", {ELF::EM_AARCH64, true, true}},
-    {"elf64-littleaarch64", {ELF::EM_AARCH64, true, true}},
+    {"elf64-aarch64",
+     {FileFormat::ELF, {ELF::EM_AARCH64, ELF::ELFOSABI_NONE, true, true}}},
+    {"elf64-littleaarch64",
+     {FileFormat::ELF, {ELF::EM_AARCH64, ELF::ELFOSABI_NONE, true, true}}},
     // RISC-V
-    {"elf32-littleriscv", {ELF::EM_RISCV, false, true}},
-    {"elf64-littleriscv", {ELF::EM_RISCV, true, true}},
+    {"elf32-littleriscv",
+     {FileFormat::ELF, {ELF::EM_RISCV, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf64-littleriscv",
+     {FileFormat::ELF, {ELF::EM_RISCV, ELF::ELFOSABI_NONE, true, true}}},
     // PowerPC
-    {"elf32-powerpc", {ELF::EM_PPC, false, false}},
-    {"elf32-powerpcle", {ELF::EM_PPC, false, true}},
-    {"elf64-powerpc", {ELF::EM_PPC64, true, false}},
-    {"elf64-powerpcle", {ELF::EM_PPC64, true, true}},
+    {"elf32-powerpc",
+     {FileFormat::ELF, {ELF::EM_PPC, ELF::ELFOSABI_NONE, false, false}}},
+    {"elf32-powerpcle",
+     {FileFormat::ELF, {ELF::EM_PPC, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf64-powerpc",
+     {FileFormat::ELF, {ELF::EM_PPC64, ELF::ELFOSABI_NONE, true, false}}},
+    {"elf64-powerpcle",
+     {FileFormat::ELF, {ELF::EM_PPC64, ELF::ELFOSABI_NONE, true, true}}},
     // MIPS
-    {"elf32-bigmips", {ELF::EM_MIPS, false, false}},
-    {"elf32-ntradbigmips", {ELF::EM_MIPS, false, false}},
-    {"elf32-ntradlittlemips", {ELF::EM_MIPS, false, true}},
-    {"elf32-tradbigmips", {ELF::EM_MIPS, false, false}},
-    {"elf32-tradlittlemips", {ELF::EM_MIPS, false, true}},
-    {"elf64-tradbigmips", {ELF::EM_MIPS, true, false}},
-    {"elf64-tradlittlemips", {ELF::EM_MIPS, true, true}},
+    {"elf32-bigmips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, false}}},
+    {"elf32-ntradbigmips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, false}}},
+    {"elf32-ntradlittlemips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf32-tradbigmips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, false}}},
+    {"elf32-tradlittlemips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, false, true}}},
+    {"elf64-tradbigmips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, true, false}}},
+    {"elf64-tradlittlemips",
+     {FileFormat::ELF, {ELF::EM_MIPS, ELF::ELFOSABI_NONE, true, true}}},
+    // SPARC
+    {"elf32-sparc",
+     {FileFormat::ELF, {ELF::EM_SPARC, ELF::ELFOSABI_NONE, false, true}}},
 };
 
-static Expected<MachineInfo> getOutputFormatMachineInfo(StringRef Format) {
+static Expected<std::pair<FileFormat, MachineInfo>>
+getFileFormatInfoByFormatName(StringRef Format) {
   StringRef OriginalFormat = Format;
   bool IsFreeBSD = Format.consume_back("-freebsd");
-  auto Iter = OutputFormatMap.find(Format);
-  if (Iter == std::end(OutputFormatMap))
+  auto Iter = FileFormatMap.find(Format);
+  if (Iter == std::end(FileFormatMap))
     return createStringError(errc::invalid_argument,
                              "Invalid output format: '%s'",
                              OriginalFormat.str().c_str());
-  MachineInfo MI = Iter->getValue();
+  auto Pair = Iter->getValue();
   if (IsFreeBSD)
-    MI.OSABI = ELF::ELFOSABI_FREEBSD;
-  return {MI};
+    Pair.second.OSABI = ELF::ELFOSABI_FREEBSD;
+  return {Pair};
 }
 
 static Error addSymbolsFromFile(std::vector<NameOrRegex> &Symbols,
                                 BumpPtrAllocator &Alloc, StringRef Filename,
                                 bool UseRegex) {
   StringSaver Saver(Alloc);
   SmallVector<StringRef, 16> Lines;
   auto BufOrErr = MemoryBuffer::getFile(Filename);
Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   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);
+  StringRef InputFormat, OutputFormat;
   if (InputArgs.hasArg(OBJCOPY_target)) {
-    Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
-    Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
+    InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
+    OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
   } else {
-    Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
-    Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
+    InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
+    OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
   }
-  if (Config.InputFormat == "binary") {
+  if (InputFormat.empty())
+    Config.InputFormat = FileFormat::Unspecified;
+  else if (InputFormat == "binary") {
+    Config.InputFormat = FileFormat::Binary;
     auto BinaryArch = InputArgs.getLastArgValue(OBJCOPY_binary_architecture);
     if (BinaryArch.empty())
       return createStringError(
           errc::invalid_argument,
           "Specified binary input without specifiying an architecture");
-    Expected<const MachineInfo &> MI = getMachineInfo(BinaryArch);
+    Expected<const MachineInfo &> MI = getMachineInfoByArchName(BinaryArch);
     if (!MI)
       return MI.takeError();
     Config.BinaryArch = *MI;
-  }
-  if (!Config.OutputFormat.empty() && Config.OutputFormat != "binary" &&
-      Config.OutputFormat != "ihex") {
-    Expected<MachineInfo> MI = getOutputFormatMachineInfo(Config.OutputFormat);
-    if (!MI)
-      return MI.takeError();
-    Config.OutputArch = *MI;
+  } else
+    return createStringError(errc::invalid_argument,
+                             "unsupported input format: '%s'",
+                             InputFormat.str().c_str());
+
+  if (OutputFormat.empty())
+    Config.OutputFormat = FileFormat::Unspecified;
+  else if (OutputFormat == "binary")
+    Config.OutputFormat = FileFormat::Binary;
+  else if (OutputFormat == "ihex")
+    Config.OutputFormat = FileFormat::IHex;
+  else {
+    Expected<std::pair<FileFormat, MachineInfo>> Pair =
+        getFileFormatInfoByFormatName(OutputFormat);
+    if (!Pair)
+      return Pair.takeError();
+    Config.OutputFormat = Pair->first;
+    Config.OutputArch = Pair->second;
   }
 
   if (auto Arg = InputArgs.getLastArg(OBJCOPY_compress_debug_sections,
                                       OBJCOPY_compress_debug_sections_eq)) {
     Config.CompressionType = DebugCompressionType::Z;
 
     if (Arg->getOption().getID() == OBJCOPY_compress_debug_sections_eq) {
       Config.CompressionType =

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

return llvm::make_unique<ELFWriter<ELF64BE>>(Obj, Buf,
                                                  !Config.StripSections);
   }
   llvm_unreachable("Invalid output format");
 }
 
 static std::unique_ptr<Writer> createWriter(const CopyConfig &Config,
                                             Object &Obj, Buffer &Buf,
                                             ElfType OutputElfType) {
-  using Functor = std::function<std::unique_ptr<Writer>()>;
-  return StringSwitch<Functor>(Config.OutputFormat)
-      .Case("binary", [&] { return llvm::make_unique<BinaryWriter>(Obj, Buf); })
-      .Case("ihex", [&] { return llvm::make_unique<IHexWriter>(Obj, Buf); })
-      .Default(
-          [&] { return createELFWriter(Config, Obj, Buf, OutputElfType); })();
+  switch (Config.OutputFormat) {
+  case FileFormat::Binary:
+    return llvm::make_unique<BinaryWriter>(Obj, Buf);
+  case FileFormat::IHex:
+    return llvm::make_unique<IHexWriter>(Obj, Buf);
+  default:
+    return createELFWriter(Config, Obj, Buf, OutputElfType);
+  }
 }
 
 template <class ELFT>
 static Expected<ArrayRef<uint8_t>>
 findBuildID(const CopyConfig &Config, const object::ELFFile<ELFT> &In) {
   auto PhdrsOrErr = In.program_headers();
   if (auto Err = PhdrsOrErr.takeError())
     return createFileError(Config.InputFilename, std::move(Err));

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

 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/WithColor.h"
static Error deepWriteArchive(StringRef ArcName,
   }
   return Error::success();
 }
 
 /// 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) {
-  // TODO: llvm-objcopy should parse CopyConfig.OutputFormat to recognize
-  // formats other than ELF / "binary" and invoke
-  // elf::executeObjcopyOnRawBinary, macho::executeObjcopyOnRawBinary or
-  // coff::executeObjcopyOnRawBinary accordingly.
+  switch (Config.OutputFormat) {
+  case FileFormat::ELF:
+  // FIXME: Currently, we use BinaryWriter/IHexWriter in the ELF implementation
+  // to convert a binary input into a binary/ihex output. Therefore, unlike GNU
+  // objcopy, it requires explicitly specifying the architecture by the -B
+  // option.
+  case FileFormat::Binary:
+  case FileFormat::IHex:
     return elf::executeObjcopyOnRawBinary(Config, In, Out);
+  case FileFormat::Unspecified:
+    return createStringError(llvm::errc::invalid_argument,
+                             "specified binary input without specifying the output file format");
+  }
 }
 
 /// The function executeObjcopyOnBinary does the dispatch based on the format
 /// of the input binary (ELF, MachO or COFF).
 static Error executeObjcopyOnBinary(const CopyConfig &Config,
                                     object::Binary &In, Buffer &Out) {
   if (auto *ELFBinary = dyn_cast<object::ELFObjectFileBase>(&In))
     return elf::executeObjcopyOnBinary(Config, *ELFBinary, Out);

 /// of input (raw binary, archive or single object file) and takes care of the
 /// format-agnostic modifications, i.e. preserving dates.
 static Error executeObjcopy(const CopyConfig &Config) {
   sys::fs::file_status Stat;
   if (Config.PreserveDates)
     if (auto EC = sys::fs::status(Config.InputFilename, Stat))
       return createFileError(Config.InputFilename, EC);
 
-  if (Config.InputFormat == "binary") {
+  if (Config.InputFormat == FileFormat::Binary) {
     auto BufOrErr = MemoryBuffer::getFile(Config.InputFilename);
     if (!BufOrErr)
       return createFileError(Config.InputFilename, BufOrErr.getError());
     FileBuffer FB(Config.OutputFilename);
     if (Error E = executeObjcopyOnRawBinary(Config, *BufOrErr->get(), FB))
       return E;
   } else {
     Expected<OwningBinary<llvm::object::Binary>> BinaryOrErr =