[llvm-objcopy] Initial XCOFF32 support.

[Esme]

Summary

This is an initial implementation of lvm-objcopy for XCOFF32.
Currently only supports simple copying, op-passthrough to follow.

[MaskRay]

llvm/test/tools/llvm-objcopy/XCOFF/basic-copy.test

26

Shouldn't the aux record follow the entry?

38

See ELF tests. We usually align the values (1 and C_EXT above, and all other values above).

[Esme]

Updated the test case.

[Esme]

Gently ping.

[shchenz]

Thanks for adding objcopy support on AIX.

Some comments from me.

I have not finished all of the code reviewing yet.

llvm/include/llvm/Object/XCOFFObjectFile.h

515

I think it should be ok to call fileHeader32 directly in the Reader?

554

We already have a getSectionContents API in this class, can we reuse that function?

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

20

use &?

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.cpp

40

From this comments, seems for now llvm-objcopy for XCOFF does not take any options? Even for -h or -v?
If so, I think the options list here should not be complete. For example, we miss StripDebug and there are also many others.

Maybe we need a new method to tell whether an option is specified instead of listing all of them.

[Esme]

Addressed @shchenz's comments and replace Buffe with streams based on D91028.

[Esme]

llvm/include/llvm/Object/XCOFFObjectFile.h

515

fileHeader32() is a private member, so I added the public function getFileHeader32().

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.cpp

40

I have no idea about the new method, so I chose to list all of these options, just like what other targets have done.

[shchenz]

Seems the functionality of the llvm-objcopy is not right. Could you please help to check? And maybe we need to add some other tests for the file format.

1:

$ llvm-objcopy 32.o copy_nodebug.o
$ dump -X32 -tv copy_nodebug.o      

copy_nodebug.o:

                        ***Symbol Table Information***
[Index] m        Value       Scn   Aux  Sclass    Type            Name
[Index] a0                                                        Fname
[Index] a1      Tagndx      Lnno  Size  Lnoptr    Endndx
[Index] a2      Tagndx            Fsiz  Lnoptr    Endndx
[Index] a3      Tagndx      Lnno  Size  Dimensions
[Index] a4   CSlen     PARMhsh SNhash SMtype SMclass Stab SNstab
[Index] a5      SECTlen    #RELent    #LINnums

[0]     m   0x00000000     undef     1  extern                    errno
[1]     a4  0x05e80000   a1f00 8192     US       ??   48 7936
[2]     m   0x00000000     undef     1  extern                    exit
[3]     a4  0x1f002000 5f80000    4     ??       PR 536872444    0
[4]     m   0x00000000     undef     1  extern                    atexit
[5]     a4  0x0000000e1f002000 1544     ER       PR 7936 8192
dump: copy_nodebug.o: dump: 0654-103 Cannot read from the specified file.
[6]     m   0x00000000     undef     1  extern                    **Invalid Symbol Name**

2: (with DWARF info)

$llvm-dwarfdump -a copy_debug.o
Program aborted due to an unhandled Error:
The end of the file was unexpectedly encountered
0.      Program arguments: llvm-dwarfdump -a copy.o
IOT/Abort trap (core dumped)

llvm/include/llvm/Object/XCOFFObjectFile.h

515

If so, I think it's better to make the private function public.

[Esme]

Good catch, thanks!

In D97656#2676095, @shchenz wrote:

Seems the functionality of the llvm-objcopy is not right. Could you please help to check? And maybe we need to add some other tests for the file format.

1:

$ llvm-objcopy 32.o copy_nodebug.o
$ dump -X32 -tv copy_nodebug.o      
...
dump: copy_nodebug.o: dump: 0654-103 Cannot read from the specified file.
[6]     m   0x00000000     undef     1  extern                    **Invalid Symbol Name**

I will add the support for writing symbol name to StringTable in next update, which may fix the issue.

2: (with DWARF info)

$llvm-dwarfdump -a copy_debug.o
Program aborted due to an unhandled Error:
The end of the file was unexpectedly encountered
0.      Program arguments: llvm-dwarfdump -a copy.o
IOT/Abort trap (core dumped)

The patch does not support reading and writing debug info. Do you think I should add it to the patch?

[shchenz]

The patch does not support reading and writing debug info. Do you think I should add it to the patch?

Should we distinguish the DWARF sections and the non DWARF sections for now? From the XCOFFReader and XCOFFWriter class, I can not tell why and how the DWARF sections are skipped.

[Esme]

Added the support for writing symbol names to the string table.

[Esme]

In D97656#2676135, @shchenz wrote:

The patch does not support reading and writing debug info. Do you think I should add it to the patch?

Should we distinguish the DWARF sections and the non DWARF sections for now? From the XCOFFReader and XCOFFWriter class, I can not tell why and how the DWARF sections are skipped.

The DWARF-related failure still exists in the latest update. I will have a look into the problem.

[Esme]

Rebase on D85774.

[jhenderson]

You need testing for your error paths, I think.

llvm/test/tools/llvm-objcopy/XCOFF/basic-copy.test

8

10–19

Maybe add a comment to the final section consisting solely of "Flags" to clarify that it is a nameless and empty section? It might make more sense to put the empty section earlier in the sections too, to show the impact (or lack thereof) it has on the later section offsets.

12

Do we really need this much data? Seems to me like a few arbitrary bytes (e.g. "12345678") would be sufficient.

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

42

Should this be a const &?

llvm/tools/llvm-objcopy/XCOFF/Writer.cpp

20–22

Why not as inline?

21

"header" rather than "headers" maybe? Is there more than one file header after all?

26

Rather than these comments, maybe it would be clearer if you split this function into multiple functions, e.g. finalizeHeader, finalizeSections etc.

65

Similar to above, I'd move these blocks into separate functions. That way, if they need to increase in complexity here, it's easy to do so.

87

Rel or Reloc are generally more common abbreviations for "Relocation" in other parts of the code. I'd recommend renaming here to match.

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.h

33

Nit: add new line at EOF.

[Esme]

Rebased the patch.
Error path test to be added...

[jhenderson]

Aside from a few nits, and the acknowledged missing error path testing, this seems reasonable to me, but requires someone with XCOFF knowledge to review too.

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

53

SymbolRef is designed to be easily copyable. No need for const &.

llvm/tools/llvm-objcopy/XCOFF/Writer.cpp

46

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.h

33

Now there are too many new lines :D

Delete line 33. There should be a '\n' at the end of line 32, as the last byte in the file.

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

209

Are there likely to be any XCOFF-specific options added in the future? If not, I wonder if we could drop XCOFFConfig entirely. We'd still want the check for unsupported options, but perhaps that should be in a different function then (e.g. Config.checkXCOFFOptions()). What do you think?

(If there are XCOFF-specific options that are planned, having a separate config, even though empty for now, is fine).

[Esme]

1. Address comment.
2. Add fields of OptionalFileHeader, AuxSymbolEntries, and LineNumInfo, otherwise an error will occur when using the compiled binary as input. (OptionalFileHeader and AuxSymbolEntries are not supported yet, just copy their contents directly.)
3. Add error tests except for the error path in getLineNumberInfo because yaml2obj does not support it.
4. Add a binary test with LineNumInfo and AuxSymbolEntries.

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

209

There isn't a concrete plan yet, but I think it is quite possible to add XCOFF-specific options in the future. So I think it's fine to keep this?

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

962

Be consistent in the style of your assert messages - the version above has no trailing full stop, but this one.

There isn't a single style specified for asserts in LLVM, but for error messages, the agreed-upon style, where surrounding code does not differ from it, is no leading capital letter, and no trailing full stop.

1055

llvm/test/tools/llvm-objcopy/XCOFF/binary-copy.test

1–2 ↗

(On Diff #373181)

Is there a particular need for you to get the llvm-objcopy implementation landed, before you have added the yaml2obj functionality? By adding a binary to the git repository, it will always stay in the repo history, even if it is later deleted, using up disk space on everybody's machines, slowing down clone times etc.

llvm/test/tools/llvm-objcopy/XCOFF/invalid-section.test

8 ↗

(On Diff #373181)

Here and below, these error messages need improving to include additional context about what has gone wrong. For example, which section couldn't be read? What was its expected size and offset? Potentially event what was the file size?

Take a look at some examples from other tests:
llvm-objcopy\ELF\invalid-p_filesz-p_offset.test
llvm-readobj\ELF\addrsig.test (this one uses warnings, but the same message context is still important)

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

33

Add TODO: to these comments.

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

71–74

Do we need something to protect us from accidentally running off the end of the file, if it's been truncated somehow?

91–93

As above, do we need to check to make sure we don't end up reading off the end of the file?

I think it might be better to emit an error and stop, saying "optional headers are not yet supported" or something to that effect, so that we don't end up producing a potentially invalid output. Same goes with the aux symbol entries.

95

Typo?

llvm/tools/llvm-objcopy/XCOFF/Writer.cpp

66

(but see also my above comment)

[Esme]

@jhenderson Thank you so much for your comments!
I will rework this patch after implementing interfaces such as aux symbol and optional header and adding yaml2obj functionality.

[Esme]

1. Addressed comments.
2. Replaced binary inputs with YAMLs for testing.
3. Updated tests for error paths.

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

702

Why is Start a uintptr_t rather than either a const char * or const uint8_t * (or even a StringRef or ArrayRef<uint8_t>)?

I also don't see this test being tested.

706

Rather than "the raw data" here, perhaps you should pass in a "Name" parameter which is used to describe what the raw data is, e.g. a symbol or similar, so that the error message is more meaningful: "symbol with offset 0x1234 and size 0x4321 goes past the end of the file".

708

llvm/test/tools/llvm-objcopy/XCOFF/invalid-read.test

5

I'd delete the "Error1: " bit of this comment (and similar bits in others), as it doesn't really add much value, but also has a risk of being confused with the FileCheck check prefix ERROR1.

Also, there's a copy-and-paste error further down with it :)

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

71–74

I'm probably being dumb, but where is this checked?

[Esme]

llvm/lib/Object/XCOFFObjectFile.cpp

702

Hmm, the function is called by objcopy when reading aux symbols. It looks like we can test this by making the StartOffset + SymbolEntrySize * NumberOfAuxEntries exceed the end of the file, where the NumberOfAuxEntries is user definable in the yaml, but I still can't construct such a case because we use zeros padding when the defined number is greater than the actual number of aux symbols in yaml2obj.

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

71–74

Do we need something to protect us from accidentally running off the end of the file, if it's been truncated somehow?

It was a comment in reading auxiliary symbols. Now I read the data by calling XCOFFObjectFile::getRawData, which has an offset check.

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

702

Fair enough. I'd add a TODO comment saying this path is untested.

ELF yaml2obj has support for raw "Content" fields that allow overriding the contents of a section. It may be worth considering something similar for XCOFF to test this case.

704

Name should be a StringRef.

710

Rather than this awkward "go/goes", could you use "goes" only, and use singular terms for the Name parameter, e.g. "relocation data" or "symbol data" rather than "relocations" or "symbols"?

[Esme]

Addressed comments.

llvm/lib/Object/XCOFFObjectFile.cpp

702

Nice suggestion, thx!

[jhenderson]

Thanks, looks good. You should get somebody with XCOFF knowledge to take another look though too.

[jhenderson]

Oh, forgot to mention: you need to revise this patch on @avl's work to move objcopy code into a library, as it will clash.

[Esme]

Revised this patch on @avl 's work, i.e. D88827, D120345, D114664 and D114429.

[jhenderson]

Looks good still.

[shchenz]

LGTM with one nit. Thanks for adding this support.

Have you tried this patch with objects generated by other tools, like XLC?

llvm/lib/ObjCopy/XCOFF/XCOFFReader.cpp

45 ↗

(On Diff #410692)

Can we use std::move(ReadSec) here to avoid unnecessary copy?

70 ↗

(On Diff #410692)

Can we use std::move(ReadSym) here to avoid unnecessary copy?

[Esme]

In D97656#3342197, @shchenz wrote:

LGTM with one nit. Thanks for adding this support.

Have you tried this patch with objects generated by other tools, like XLC?

Yes, I have tested that case too.

llvm/include/llvm/Object/XCOFFObjectFile.h

 private:
   const void *FileHeader = nullptr;
   const void *AuxiliaryHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const void *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 
-  const XCOFFFileHeader32 *fileHeader32() const;
-  const XCOFFFileHeader64 *fileHeader64() const;
-
   const XCOFFSectionHeader32 *sectionHeaderTable32() const;
   const XCOFFSectionHeader64 *sectionHeaderTable64() const;
   template <typename T> const T *sectionHeaderTable() const;
 
   size_t getFileHeaderSize() const;
   size_t getSectionHeaderSize() const;
 
   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
public:
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   Expected<uint64_t> getStartAddress() const override;
   StringRef mapDebugSectionName(StringRef Name) const override;
   bool isRelocatableObject() const override;
 
   // Below here is the non-inherited interface.
   bool is64Bit() const;
+  Expected<StringRef> getRawData(const char *Start, uint64_t Size,
+                                 StringRef Name) const;
 
   const XCOFFAuxiliaryHeader32 *auxiliaryHeader32() const;
   const XCOFFAuxiliaryHeader64 *auxiliaryHeader64() const;
 
   const void *getPointerToSymbolTable() const { return SymbolTblPtr; }
 
   Expected<StringRef> getSymbolSectionName(XCOFFSymbolRef Ref) const;
   unsigned getSymbolSectionID(SymbolRef Sym) const;
   XCOFFSymbolRef toSymbolRef(DataRefImpl Ref) const;
 
   // File header related interfaces.
+  const XCOFFFileHeader32 *fileHeader32() const;
+  const XCOFFFileHeader64 *fileHeader64() const;
   uint16_t getMagic() const;
   uint16_t getNumberOfSections() const;
   int32_t getTimeStamp() const;
 
   // Symbol table offset and entry count are handled differently between
   // XCOFF32 and XCOFF64.
   uint32_t getSymbolTableOffset32() const;
   uint64_t getSymbolTableOffset64() const;
 
   // Note that this value is signed and might return a negative value. Negative
   // values are reserved for future use.
   int32_t getRawNumberOfSymbolTableEntries32() const;
public:
 
   // Section header table related interfaces.
   ArrayRef<XCOFFSectionHeader32> sections32() const;
   ArrayRef<XCOFFSectionHeader64> sections64() const;
 
   int32_t getSectionFlags(DataRefImpl Sec) const;
   Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
   void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;
 
   // Relocation-related interfaces.
   template <typename T>
   Expected<uint32_t>
   getNumberOfRelocationEntries(const XCOFFSectionHeader<T> &Sec) const;
 
   template <typename Shdr, typename Reloc>
   Expected<ArrayRef<Reloc>> relocations(const Shdr &Sec) const;
assert(SymEntDataRef.p != 0 &&
            "Symbol table entry pointer cannot be nullptr!");
 
     if (OwningObjectPtr->is64Bit())
       Entry64 = reinterpret_cast<const XCOFFSymbolEntry64 *>(SymEntDataRef.p);
     else
       Entry32 = reinterpret_cast<const XCOFFSymbolEntry32 *>(SymEntDataRef.p);
   }
 
+  const XCOFFSymbolEntry32 *getSymbol32() { return Entry32; }
+  const XCOFFSymbolEntry64 *getSymbol64() { return Entry64; }
+
   uint64_t getValue() const { return Entry32 ? getValue32() : getValue64(); }
 
   uint32_t getValue32() const { return Entry32->Value; }
 
   uint64_t getValue64() const { return Entry64->Value; }
 
 #define GETVALUE(X) Entry32 ? Entry32->X : Entry64->X
 

llvm/lib/Object/XCOFFObjectFile.cpp

size_t XCOFFObjectFile::getSectionHeaderSize() const {
   return is64Bit() ? sizeof(XCOFFSectionHeader64) :
                      sizeof(XCOFFSectionHeader32);
 }
 
 bool XCOFFObjectFile::is64Bit() const {
   return Binary::ID_XCOFF64 == getType();
 }
 
+Expected<StringRef> XCOFFObjectFile::getRawData(const char *Start,
+                                                uint64_t Size,
+                                                StringRef Name) const {
+  uintptr_t StartPtr = reinterpret_cast<uintptr_t>(Start);
+  // TODO: this path is untested.
+  if (Error E = Binary::checkOffset(Data, StartPtr, Size))
+    return createError(toString(std::move(E)) + ": " + Name.data() +
+                       " data with offset 0x" + Twine::utohexstr(StartPtr) +
+                       " and size 0x" + Twine::utohexstr(Size) +
+                       " goes past the end of the file");
+  return StringRef(Start, Size);
+}
+
 uint16_t XCOFFObjectFile::getMagic() const {
   return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
 }
 
 Expected<DataRefImpl> XCOFFObjectFile::getSectionByNum(int16_t Num) const {
   if (Num <= 0 || Num > getNumberOfSections())
     return createStringError(object_error::invalid_section_index,
                              "the section index (" + Twine(Num) +

 XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
   // If there is a string table, then the buffer must contain at least 4 bytes
   // for the string table's size. Not having a string table is not an error.
   if (Error E = Binary::checkOffset(
           Obj->Data, reinterpret_cast<uintptr_t>(Obj->base() + Offset), 4)) {
     consumeError(std::move(E));
     return XCOFFStringTable{0, nullptr};
   }
 
   // Read the size out of the buffer.
   uint32_t Size = support::endian::read32be(Obj->base() + Offset);
 
   // If the size is less then 4, then the string table is just a size and no
   // string data.
   if (Size <= 4)
     return XCOFFStringTable{4, nullptr};
 
auto FileHeaderOrErr =
       getObject<void>(Data, Base + CurOffset, Obj->getFileHeaderSize());
   if (Error E = FileHeaderOrErr.takeError())
     return std::move(E);
   Obj->FileHeader = FileHeaderOrErr.get();
 
   CurOffset += Obj->getFileHeaderSize();
 
   if (Obj->getOptionalHeaderSize()) {
     auto AuxiliaryHeaderOrErr =
         getObject<void>(Data, Base + CurOffset, Obj->getOptionalHeaderSize());
     if (Error E = AuxiliaryHeaderOrErr.takeError())
       return std::move(E);
     Obj->AuxiliaryHeader = AuxiliaryHeaderOrErr.get();
   }
 
   CurOffset += Obj->getOptionalHeaderSize();
 

llvm/test/tools/llvm-objcopy/XCOFF/basic-copy.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy %t %t.out
+# RUN: cmp %t %t.out
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+AuxiliaryHeader:
+  Magic: 0x10B
+Sections:
+  - Name:        .text
+    Flags:       [ STYP_TEXT ]
+    SectionData: "123456"
+  - Name:        .data
+    Flags:       [ STYP_DATA ]
+    SectionData: "067891"
+    Relocations:
+      - Address: 0x3A
+        Type:    0x02
+Symbols:
+  - Name:         aux_fcn_csect
+    StorageClass: C_EXT
+    Type:         0x20
+    AuxEntries:
+      - Type: AUX_FCN
+      - Type: AUX_CSECT
+  - Name:         aux_stat
+    StorageClass: C_STAT
+    AuxEntries:
+      - Type: AUX_STAT
+...

llvm/test/tools/llvm-objcopy/XCOFF/invalid-read.test

+## Check that llvm-objcopy reports a suitable error when it
+## encounters invalid input during reading.
+
+## Failed to read section data.
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: not llvm-objcopy %t1 %t1.out 2>&1 | FileCheck %s -DFILE=%t1 --check-prefix=ERROR1
+
+# ERROR1: error: '[[FILE]]': The end of the file was unexpectedly encountered: section data with offset 0x70 and size 0x4 goes past the end of the file
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x01DF
+Sections:
+  - SectionData:      '00007400'
+    FileOffsetToData: 0x70
+
+## Failed to read relocations.
+# RUN: yaml2obj %s --docnum=2 -o %t2
+# RUN: not llvm-objcopy %t2 %t2.out 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=ERROR2
+
+# ERROR2: error: '[[FILE]]': The end of the file was unexpectedly encountered: relocations with offset 0x3c and size 0x1e go past the end of the file
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x01DF
+Sections:
+  - NumberOfRelocations: 0x3
+    Relocations:
+      - Address: 0xE
+        Symbol:  0x12
+        Info:    0xF
+        Type:    0x3
+
+## Failed to read the symbols.
+# RUN: yaml2obj %s --docnum=3 -o %t3
+# RUN: not llvm-objcopy %t3 %t3.out 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=ERROR3
+
+# ERROR3: error: '[[FILE]]': The end of the file was unexpectedly encountered: symbol table with offset 0x15 and size 0x24 goes past the end of the file
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:         0x01DF
+  OffsetToSymbolTable: 0x15
+Symbols:
+  - Name:         foo
+    AuxEntries:
+      - Type: AUX_CSECT

llvm/tools/llvm-objcopy/CMakeLists.txt

add_llvm_tool(llvm-objcopy
   MachO/MachOReader.cpp
   MachO/MachOWriter.cpp
   MachO/MachOLayoutBuilder.cpp
   MachO/Object.cpp
   wasm/Object.cpp
   wasm/Reader.cpp
   wasm/Writer.cpp
   wasm/WasmObjcopy.cpp
+  XCOFF/Reader.cpp
+  XCOFF/Writer.cpp
+  XCOFF/XCOFFObjcopy.cpp
   DEPENDS
   ObjcopyOptsTableGen
   InstallNameToolOptsTableGen
   StripOptsTableGen
   )
 
 add_llvm_tool_symlink(llvm-install-name-tool llvm-objcopy)
 add_llvm_tool_symlink(llvm-bitcode-strip llvm-objcopy)

llvm/tools/llvm-objcopy/ConfigManager.h

 #define LLVM_TOOLS_LLVM_OBJCOPY_CONFIGMANAGER_H
 
 #include "COFF/COFFConfig.h"
 #include "CommonConfig.h"
 #include "ELF/ELFConfig.h"
 #include "MachO/MachOConfig.h"
 #include "MultiFormatConfig.h"
 #include "wasm/WasmConfig.h"
+#include "XCOFF/XCOFFConfig.h"
 #include "llvm/Support/Allocator.h"
 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 
 // ConfigManager keeps all configurations and prepare
 // format-specific options.
 struct ConfigManager : public MultiFormatConfig {
   virtual ~ConfigManager() {}
 
   const CommonConfig &getCommonConfig() const override { return Common; }
   Expected<const ELFConfig &> getELFConfig() const override;
   Expected<const COFFConfig &> getCOFFConfig() const override;
   Expected<const MachOConfig &> getMachOConfig() const override;
   Expected<const WasmConfig &> getWasmConfig() const override;
+  Expected<const XCOFFConfig &> getXCOFFConfig() const override;
 
   // All configs.
   CommonConfig Common;
   ELFConfig ELF;
   COFFConfig COFF;
   MachOConfig MachO;
   WasmConfig Wasm;
+  XCOFFConfig XCOFF;
 };
 
 // Configuration for the overall invocation of this tool. When invoked as
 // objcopy, will always contain exactly one CopyConfig. When invoked as strip,
 // will contain one or more CopyConfigs.
 struct DriverConfig {
   SmallVector<ConfigManager, 1> CopyConfigs;
   BumpPtrAllocator Alloc;

llvm/tools/llvm-objcopy/ConfigManager.cpp

if (!Common.AddGnuDebugLink.empty() || Common.ExtractPartition ||
     return createStringError(
         llvm::errc::invalid_argument,
         "only flags for section dumping, removal, and addition are supported");
   }
 
   return Wasm;
 }
 
+Expected<const XCOFFConfig &> ConfigManager::getXCOFFConfig() const {
+  if (!Common.AddGnuDebugLink.empty() || Common.ExtractPartition ||
+      !Common.SplitDWO.empty() || !Common.SymbolsPrefix.empty() ||
+      !Common.AllocSectionsPrefix.empty() ||
+      Common.DiscardMode != DiscardType::None || !Common.AddSection.empty() ||
+      !Common.DumpSection.empty() || !Common.SymbolsToAdd.empty() ||
+      !Common.KeepSection.empty() || !Common.OnlySection.empty() ||
+      !Common.ToRemove.empty() || !Common.SymbolsToGlobalize.empty() ||
+      !Common.SymbolsToKeep.empty() || !Common.SymbolsToLocalize.empty() ||
+      !Common.SymbolsToRemove.empty() ||
+      !Common.UnneededSymbolsToRemove.empty() ||
+      !Common.SymbolsToWeaken.empty() || !Common.SymbolsToKeepGlobal.empty() ||
+      !Common.SectionsToRename.empty() || !Common.SetSectionAlignment.empty() ||
+      !Common.SetSectionFlags.empty() || !Common.SymbolsToRename.empty() ||
+      Common.ExtractDWO || Common.ExtractMainPartition ||
+      Common.OnlyKeepDebug || Common.PreserveDates || Common.StripAllGNU ||
+      Common.StripDWO || Common.StripDebug || Common.StripNonAlloc ||
+      Common.StripSections || Common.Weaken || Common.StripUnneeded ||
+      Common.DecompressDebugSections) {
+    return createStringError(
+        llvm::errc::invalid_argument,
+        "no flags are supported yet, only basic copying is allowed");
+  }
+
+  return XCOFF;
+}
+
 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseObjcopyOptions will print the help messege and
 // exit.
 Expected<DriverConfig>
 objcopy::parseObjcopyOptions(ArrayRef<const char *> RawArgsArr,
                              function_ref<Error(Error)> ErrorCallback) {
   DriverConfig DC;
   ObjcopyOptTable T;

llvm/tools/llvm-objcopy/MultiFormatConfig.h

 namespace llvm {
 namespace objcopy {
 
 struct CommonConfig;
 struct ELFConfig;
 struct COFFConfig;
 struct MachOConfig;
 struct WasmConfig;
+struct XCOFFConfig;
 
 class MultiFormatConfig {
 public:
   virtual ~MultiFormatConfig() {}
 
   virtual const CommonConfig &getCommonConfig() const = 0;
   virtual Expected<const ELFConfig &> getELFConfig() const = 0;
   virtual Expected<const COFFConfig &> getCOFFConfig() const = 0;
   virtual Expected<const MachOConfig &> getMachOConfig() const = 0;
   virtual Expected<const WasmConfig &> getWasmConfig() const = 0;
+  virtual Expected<const XCOFFConfig &> getXCOFFConfig() const = 0;
 };
 
 } // namespace objcopy
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_OBJCOPY_MULTIFORMATCONFIG_H

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

+//===- Object.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_XCOFF_OBJECT_H
+#define LLVM_TOOLS_OBJCOPY_XCOFF_OBJECT_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include <vector>
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+struct Section {
+  XCOFFSectionHeader32 SectionHeader;
+  ArrayRef<uint8_t> Contents;
+  std::vector<XCOFFRelocation32> Relocations;
+};
+
+struct Symbol {
+  XCOFFSymbolEntry32 Sym;
+  // For now, each auxiliary symbol is only an opaque binary blob with no
+  // distinction.
+  StringRef AuxSymbolEntries;
+};
+
+struct Object {
+  XCOFFFileHeader32 FileHeader;
+  XCOFFAuxiliaryHeader32 OptionalFileHeader;
+  std::vector<Section> Sections;
+  std::vector<Symbol> Symbols;
+  StringRef StringTable;
+};
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_XCOFF_OBJECT_H

llvm/tools/llvm-objcopy/XCOFF/Reader.h

+//===- Reader.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_XCOFF_READER_H
+#define LLVM_TOOLS_OBJCOPY_XCOFF_READER_H
+
+#include "Object.h"
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+class XCOFFReader {
+public:
+  explicit XCOFFReader(const XCOFFObjectFile &O) : XCOFFObj(O) {}
+  Expected<std::unique_ptr<Object>> create() const;
+
+private:
+  const XCOFFObjectFile &XCOFFObj;
+  Error readSections(Object &Obj) const;
+  Error readSymbols(Object &Obj) const;
+};
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_XCOFF_READER_H

llvm/tools/llvm-objcopy/XCOFF/Reader.cpp

+//===- Reader.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 "Reader.h"
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+Error XCOFFReader::readSections(Object &Obj) const {
+  ArrayRef<XCOFFSectionHeader32> Sections = XCOFFObj.sections32();
+  for (const XCOFFSectionHeader32 &Sec : Sections) {
+    Section ReadSec;
+    // Section header.
+    ReadSec.SectionHeader = Sec;
+    DataRefImpl SectionDRI;
+    SectionDRI.p = reinterpret_cast<uintptr_t>(&Sec);
+
+    // Section data.
+    if (Sec.SectionSize) {
+      Expected<ArrayRef<uint8_t>> ContentsRef =
+          XCOFFObj.getSectionContents(SectionDRI);
+      if (!ContentsRef)
+        return ContentsRef.takeError();
+      ReadSec.Contents = ContentsRef.get();
+    }
+
+    // Relocations.
+    if (Sec.NumberOfRelocations) {
+      auto Relocations =
+          XCOFFObj.relocations<XCOFFSectionHeader32, XCOFFRelocation32>(Sec);
+      if (!Relocations)
+        return Relocations.takeError();
+      for (const XCOFFRelocation32 &Rel : Relocations.get())
+        ReadSec.Relocations.push_back(Rel);
+    }
+
+    Obj.Sections.push_back(ReadSec);
+  }
+  return Error::success();
+}
+
+Error XCOFFReader::readSymbols(Object &Obj) const {
+  std::vector<Symbol> Symbols;
+  Symbols.reserve(XCOFFObj.getNumberOfSymbolTableEntries());
+  for (SymbolRef Sym : XCOFFObj.symbols()) {
+    Symbol ReadSym;
+    DataRefImpl SymbolDRI = Sym.getRawDataRefImpl();
+    XCOFFSymbolRef SymbolEntRef = XCOFFObj.toSymbolRef(SymbolDRI);
+    ReadSym.Sym = *SymbolEntRef.getSymbol32();
+    // Auxiliary entries.
+    if (SymbolEntRef.getNumberOfAuxEntries()) {
+      const char *Start = reinterpret_cast<const char *>(
+          SymbolDRI.p + XCOFF::SymbolTableEntrySize);
+      Expected<StringRef> RawAuxEntriesOrError = XCOFFObj.getRawData(
+          Start,
+          XCOFF::SymbolTableEntrySize * SymbolEntRef.getNumberOfAuxEntries(),
+          StringRef("symbols"));
+      if (!RawAuxEntriesOrError)
+        return RawAuxEntriesOrError.takeError();
+      ReadSym.AuxSymbolEntries = RawAuxEntriesOrError.get();
+    }
+
+    Obj.Symbols.push_back(ReadSym);
+  }
+  return Error::success();
+}
+
+Expected<std::unique_ptr<Object>> XCOFFReader::create() const {
+  auto Obj = std::make_unique<Object>();
+  // Only 32-bit supported now.
+  if (XCOFFObj.is64Bit())
+    return createStringError(object_error::invalid_file_type,
+                             "64-bit XCOFF is not supported yet");
+  // Read the file header.
+  Obj->FileHeader = *XCOFFObj.fileHeader32();
+  // Read the optional header.
+  if (XCOFFObj.getOptionalHeaderSize())
+    Obj->OptionalFileHeader = *XCOFFObj.auxiliaryHeader32();
+  // Read each section.
+  Obj->Sections.reserve(XCOFFObj.getNumberOfSections());
+  if (Error E = readSections(*Obj))
+    return std::move(E);
+  // Read each symbol.
+  Obj->Symbols.reserve(XCOFFObj.getRawNumberOfSymbolTableEntries32());
+  if (Error E = readSymbols(*Obj))
+    return std::move(E);
+  // String table.
+  Obj->StringTable = XCOFFObj.getStringTable();
+  return std::move(Obj);
+}
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/XCOFF/Writer.h

+//===- Writer.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_XCOFF_WRITER_H
+#define LLVM_TOOLS_OBJCOPY_XCOFF_WRITER_H
+
+#include "Object.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+class XCOFFWriter {
+public:
+  virtual ~XCOFFWriter() {}
+  XCOFFWriter(Object &Obj, raw_ostream &Out) : Obj(Obj), Out(Out) {}
+  Error write();
+
+private:
+  Object &Obj;
+  raw_ostream &Out;
+  std::unique_ptr<WritableMemoryBuffer> Buf;
+  size_t FileSize;
+
+  void finalizeHeaders();
+  void finalizeSections();
+  void finalizeSymbolStringTable();
+  void finalize();
+
+  void writeHeaders();
+  void writeSections();
+  void writeSymbolStringTable();
+};
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_OBJCOPY_XCOFF_WRITER_H

llvm/tools/llvm-objcopy/XCOFF/Writer.cpp

+//===- Writer.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 "Writer.h"
+#include "llvm/Support/Errc.h"
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+void XCOFFWriter::finalizeHeaders() {
+  // File header.
+  FileSize += sizeof(XCOFFFileHeader32);
+  // Optional file header.
+  FileSize += Obj.FileHeader.AuxHeaderSize;
+  // Section headers.
+  FileSize += sizeof(XCOFFSectionHeader32) * Obj.Sections.size();
+}
+
+void XCOFFWriter::finalizeSections() {
+  for (const Section &Sec : Obj.Sections) {
+    // Section data.
+    FileSize += Sec.Contents.size();
+    // Relocations.
+    FileSize +=
+        Sec.SectionHeader.NumberOfRelocations * sizeof(XCOFFRelocation32);
+  }
+}
+
+void XCOFFWriter::finalizeSymbolStringTable() {
+  assert(Obj.FileHeader.SymbolTableOffset >= FileSize);
+  FileSize = Obj.FileHeader.SymbolTableOffset;
+  // Symbols and auxiliary entries.
+  FileSize +=
+      Obj.FileHeader.NumberOfSymTableEntries * XCOFF::SymbolTableEntrySize;
+  // String table.
+  FileSize += Obj.StringTable.size();
+}
+
+void XCOFFWriter::finalize() {
+  FileSize = 0;
+  finalizeHeaders();
+  finalizeSections();
+  finalizeSymbolStringTable();
+}
+
+void XCOFFWriter::writeHeaders() {
+  // Write the file header.
+  uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
+  memcpy(Ptr, &Obj.FileHeader, sizeof(XCOFFFileHeader32));
+  Ptr += sizeof(XCOFFFileHeader32);
+
+  // Write the optional header.
+  if (Obj.FileHeader.AuxHeaderSize) {
+    memcpy(Ptr, &Obj.OptionalFileHeader, Obj.FileHeader.AuxHeaderSize);
+    Ptr += Obj.FileHeader.AuxHeaderSize;
+  }
+
+  // Write section headers.
+  for (const Section &Sec : Obj.Sections) {
+    memcpy(Ptr, &Sec.SectionHeader, sizeof(XCOFFSectionHeader32));
+    Ptr += sizeof(XCOFFSectionHeader32);
+  }
+}
+
+void XCOFFWriter::writeSections() {
+  // Write section data.
+  for (const Section &Sec : Obj.Sections) {
+    uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+                   Sec.SectionHeader.FileOffsetToRawData;
+    Ptr = std::copy(Sec.Contents.begin(), Sec.Contents.end(), Ptr);
+  }
+
+  // Write relocations.
+  for (const Section &Sec : Obj.Sections) {
+    uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+                   Sec.SectionHeader.FileOffsetToRelocationInfo;
+    for (const XCOFFRelocation32 &Rel : Sec.Relocations) {
+      memcpy(Ptr, &Rel, sizeof(XCOFFRelocation32));
+      Ptr += sizeof(XCOFFRelocation32);
+    }
+  }
+}
+
+void XCOFFWriter::writeSymbolStringTable() {
+  // Write symbols.
+  uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+                 Obj.FileHeader.SymbolTableOffset;
+  for (const Symbol &Sym : Obj.Symbols) {
+    memcpy(Ptr, &Sym.Sym, XCOFF::SymbolTableEntrySize);
+    Ptr += XCOFF::SymbolTableEntrySize;
+    // Auxiliary symbols.
+    memcpy(Ptr, Sym.AuxSymbolEntries.data(), Sym.AuxSymbolEntries.size());
+    Ptr += Sym.AuxSymbolEntries.size();
+  }
+  // Write the string table.
+  memcpy(Ptr, Obj.StringTable.data(), Obj.StringTable.size());
+  Ptr += Obj.StringTable.size();
+}
+
+Error XCOFFWriter::write() {
+  finalize();
+  Buf = WritableMemoryBuffer::getNewMemBuffer(FileSize);
+  if (!Buf)
+    return createStringError(errc::not_enough_memory,
+                             "failed to allocate memory buffer of " +
+                                 Twine::utohexstr(FileSize) + " bytes");
+
+  writeHeaders();
+  writeSections();
+  writeSymbolStringTable();
+  Out.write(Buf->getBufferStart(), Buf->getBufferSize());
+  return Error::success();
+}
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm

llvm/tools/llvm-objcopy/XCOFF/XCOFFConfig.h

+//===- COFFConfig.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_LLVM_OBJCOPY_XCOFF_XCOFFCONFIG_H
+#define LLVM_TOOLS_LLVM_OBJCOPY_XCOFF_XCOFFCONFIG_H
+
+namespace llvm {
+namespace objcopy {
+
+// XCOFF specific configuration for copying/stripping a single file.
+struct XCOFFConfig {};
+
+} // namespace objcopy
+} // namespace llvm
+
+#endif // LLVM_TOOLS_LLVM_OBJCOPY_XCOFF_XCOFFCONFIG_H

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.h

+//===- XCOFFObjcopy.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_LLVM_OBJCOPY_XCOFFOBJCOPY_H
+#define LLVM_TOOLS_LLVM_OBJCOPY_XCOFFOBJCOPY_H
+
+namespace llvm {
+class Error;
+class raw_ostream;
+
+namespace object {
+class XCOFFObjectFile;
+} // end namespace object
+
+namespace objcopy {
+struct CommonConfig;
+struct XCOFFConfig;
+
+namespace xcoff {
+Error executeObjcopyOnBinary(const CommonConfig &Config, const XCOFFConfig &,
+                             object::XCOFFObjectFile &In, raw_ostream &Out);
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_LLVM_OBJCOPY_XCOFFOBJCOPY_H

llvm/tools/llvm-objcopy/XCOFF/XCOFFObjcopy.cpp

+//===- XCOFFObjcopy.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 "XCOFFObjcopy.h"
+#include "CommonConfig.h"
+#include "Object.h"
+#include "Reader.h"
+#include "Writer.h"
+#include "XCOFFConfig.h"
+#include "llvm/Support/Errc.h"
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+static Error handleArgs(const CommonConfig &Config, Object &Obj) {
+  return Error::success();
+}
+
+Error executeObjcopyOnBinary(const CommonConfig &Config, const XCOFFConfig &,
+                             XCOFFObjectFile &In, raw_ostream &Out) {
+  XCOFFReader Reader(In);
+  Expected<std::unique_ptr<Object>> ObjOrErr = Reader.create();
+  if (!ObjOrErr)
+    return createFileError(Config.InputFilename, ObjOrErr.takeError());
+  Object *Obj = ObjOrErr->get();
+  assert(Obj && "Unable to deserialize XCOFF object");
+  if (Error E = handleArgs(Config, *Obj))
+    return createFileError(Config.InputFilename, std::move(E));
+  XCOFFWriter Writer(*Obj, Out);
+  if (Error E = Writer.write())
+    return createFileError(Config.OutputFilename, std::move(E));
+  return Error::success();
+}
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm

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

 #include "CommonConfig.h"
 #include "ConfigManager.h"
 #include "ELF/ELFConfig.h"
 #include "ELF/ELFObjcopy.h"
 #include "MachO/MachOConfig.h"
 #include "MachO/MachOObjcopy.h"
 #include "wasm/WasmConfig.h"
 #include "wasm/WasmObjcopy.h"
+#include "XCOFF/XCOFFConfig.h"
+#include "XCOFF/XCOFFObjcopy.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
return macho::executeObjcopyOnMachOUniversalBinary(
         Config, *MachOUniversalBinary, Out);
   } else if (auto *WasmBinary = dyn_cast<object::WasmObjectFile>(&In)) {
     Expected<const WasmConfig &> WasmConfig = Config.getWasmConfig();
     if (!WasmConfig)
       return WasmConfig.takeError();
 
     return objcopy::wasm::executeObjcopyOnBinary(Config.getCommonConfig(),
                                                  *WasmConfig, *WasmBinary, Out);
+  } else if (auto *XCOFFBinary = dyn_cast<object::XCOFFObjectFile>(&In)) {
+    Expected<const XCOFFConfig &> XCOFFConfig = Config.getXCOFFConfig();
+    if (!XCOFFConfig)
+      return XCOFFConfig.takeError();
+
+    return xcoff::executeObjcopyOnBinary(Config.getCommonConfig(), *XCOFFConfig,
+                                         *XCOFFBinary, Out);
   } else
     return createStringError(object_error::invalid_file_type,
                              "unsupported object file format");
 }
 
 namespace llvm {
 namespace objcopy {