[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

341

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

369

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

341

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

341

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

32

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

32

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

211

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

211

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

699

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.

741

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

489

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.

493

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".

495

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

4 ↗

(On Diff #400432)

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

489

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

489

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.

491

Name should be a StringRef.

497

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

489

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

public:
   }
 
   Expected<StringRef>
   getSymbolSectionName(const XCOFFSymbolEntry *SymEntPtr) const;
 
   const XCOFFSymbolEntry *toSymbolEntry(DataRefImpl Ref) const;
 
   // File header related interfaces.
+  const XCOFFFileHeader32 *getFileHeader32() 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.
   Expected<uint32_t>
   getLogicalNumberOfRelocationEntries(const XCOFFSectionHeader32 &Sec) const;
 
   Expected<ArrayRef<XCOFFRelocation32>>
   relocations(const XCOFFSectionHeader32 &) const;
 

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();
 }
 
+const XCOFFFileHeader32 *XCOFFObjectFile::getFileHeader32() const {
+  return fileHeader32();
+}
+
 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 errorCodeToError(object_error::invalid_section_index);
 
   DataRefImpl DRI;
   DRI.p = getWithOffset(getSectionHeaderTableAddress(),
                         getSectionHeaderSize() * (Num - 1));
   return DRI;
 }

 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};
 
XCOFFObjectFile::create(unsigned Type, MemoryBufferRef MBR) {
   if (Error E = FileHeaderOrErr.takeError())
     return std::move(E);
   Obj->FileHeader = FileHeaderOrErr.get();
 
   CurOffset += Obj->getFileHeaderSize();
   // TODO FIXME we don't have support for an optional header yet, so just skip
   // past it.
   CurOffset += Obj->getOptionalHeaderSize();
 
   // Parse the section header table if it is present.
   if (Obj->getNumberOfSections()) {
     auto SecHeadersOrErr = getObject<void>(Data, Base + CurOffset,
                                            Obj->getNumberOfSections() *
                                                Obj->getSectionHeaderSize());
     if (Error E = SecHeadersOrErr.takeError())
       return std::move(E);
     Obj->SectionHeaderTable = SecHeadersOrErr.get();

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

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy %t %t2
+# RUN: cmp %t %t2
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:     0x1DF
+Sections:
+  - Name:          .text
+    Flags:         0x20
+    SectionData:   "9061FFF8808200008064000038630001906400008061FFF8386300019061FFF88061FFF88082000480840000888400007C6322149061FFF88061FFF84E8000200000000000092040800001010000000000000040000466756E310000600000007C0802A693E1FFFC900100089421FFB07C3F0B7838600000907F004880620008907F0044808300003884000190830000806300004BFFFF6D60000000807F0044806300004BFFFF5D60000000382100508001000883E1FFFC7C0803A64E8000200000000000092261800100010000006000046D61696E1F006162636400000000"
+  - Name:          .data
+    Flags:         0x40
+    SectionData:   "00000000000000FC0000000000000060000000FC00000000000000D800000108000000F800000000"
+    Relocations:
+      - Address:   0x3A
+        Type:      0x02
+  - Flags:         0x80
+Symbols:
+  - Name:            .file
+    Section:         N_DEBUG
+  - Name:            .text
+    Value:           0x0
+    Section:         .text
+    Type:            0x0
+    StorageClass:    C_HIDEXT
+    NumberOfAuxEntries: 1
+  - Name:            i
+    Value:           0x0
+    Section:         .data
+    Type:            0x0
+    StorageClass:    C_EXT
+    NumberOfAuxEntries: 1

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/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 Object {
+  XCOFFFileHeader32 FileHeader;
+  std::vector<Section> Sections;
+  std::vector<XCOFFSymbolEntry> Symbols;
+};
+
+} // 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;
+    // Read section header.
+    ReadSec.SectionHeader = Sec;
+
+    // Read section data.
+    if (Sec.SectionSize) {
+      DataRefImpl SectionDRI;
+      SectionDRI.p = reinterpret_cast<uintptr_t>(&Sec);
+      Expected<ArrayRef<uint8_t>> ContentsRef =
+          XCOFFObj.getSectionContents(SectionDRI);
+      if (!ContentsRef)
+        return ContentsRef.takeError();
+      ReadSec.Contents = ContentsRef.get();
+    }
+
+    // Read relocations.
+    if (Sec.NumberOfRelocations) {
+      Expected<ArrayRef<XCOFFRelocation32>> Relocations =
+          XCOFFObj.relocations(Sec);
+      if (!Relocations)
+        return Relocations.takeError();
+      for (XCOFFRelocation32 Reloc : Relocations.get())
+        ReadSec.Relocations.push_back(Reloc);
+    }
+    Obj.Sections.push_back(ReadSec);
+  }
+  return Error::success();
+}
+
+Error XCOFFReader::readSymbols(Object &Obj) const {
+  for (const SymbolRef &S : XCOFFObj.symbols()) {
+    DataRefImpl SymbolDRI = S.getRawDataRefImpl();
+    const XCOFFSymbolEntry *SymbolEntPtr = XCOFFObj.toSymbolEntry(SymbolDRI);
+    Obj.Symbols.push_back(*SymbolEntPtr);
+  }
+  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.getFileHeader32();
+  // 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);
+  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 finalize();
+};
+
+} // 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;
+
+size_t XCOFFWriter::finalize() {
+  size_t FileSize = 0;
+  // Finalize file headers.
+  FileSize += sizeof(XCOFFFileHeader32);
+  Obj.FileHeader.NumberOfSections = Obj.Sections.size();
+  Obj.FileHeader.NumberOfSymTableEntries = Obj.Symbols.size();
+
+  // Finalize sections.
+  FileSize += sizeof(XCOFFSectionHeader32) * Obj.Sections.size();
+  for (Section &Sec : Obj.Sections) {
+    // Section data.
+    if (Sec.SectionHeader.SectionSize)
+      FileSize += Sec.SectionHeader.SectionSize;
+    // Relocations.
+    Sec.SectionHeader.NumberOfRelocations = Sec.Relocations.size();
+    if (Sec.Relocations.size())
+      FileSize += Sec.Relocations.size() * sizeof(XCOFFRelocation32);
+  }
+
+  // Finalize symbols.
+  Obj.FileHeader.SymbolTableOffset = FileSize;
+  uint32_t NumOfSymEnt = 0;
+  for (XCOFFSymbolEntry &Sym : Obj.Symbols)
+    NumOfSymEnt += 1 + Sym.NumberOfAuxEntries;
+  Obj.FileHeader.NumberOfSymTableEntries = NumOfSymEnt;
+  FileSize += NumOfSymEnt * sizeof(XCOFFSymbolEntry);
+  return FileSize;
+}
+
+Error XCOFFWriter::write() {
+  size_t TotalSize = finalize();
+  Buf = WritableMemoryBuffer::getNewMemBuffer(TotalSize);
+  if (!Buf)
+    return createStringError(errc::not_enough_memory,
+                             "failed to allocate memory buffer of " +
+                                 Twine::utohexstr(TotalSize) + " bytes");
+
+  // Write the file header.
+  uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
+  memcpy(Ptr, &Obj.FileHeader, sizeof(XCOFFFileHeader32));
+  Ptr += sizeof(XCOFFFileHeader32);
+
+  // Write section headers.
+  for (Section &Sec : Obj.Sections) {
+    memcpy(Ptr, &Sec.SectionHeader, sizeof(XCOFFSectionHeader32));
+    Ptr += sizeof(XCOFFSectionHeader32);
+  }
+
+  // Write section data.
+  for (Section &Sec : Obj.Sections) {
+    Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+          Sec.SectionHeader.FileOffsetToRawData;
+    Ptr = std::copy(Sec.Contents.begin(), Sec.Contents.end(), Ptr);
+  }
+
+  // Write relocations.
+  for (Section &Sec : Obj.Sections) {
+    Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+          Sec.SectionHeader.FileOffsetToRelocationInfo;
+    for (XCOFFRelocation32 &Relo : Sec.Relocations) {
+      memcpy(Ptr, &Relo, sizeof(XCOFFRelocation32));
+      Ptr += sizeof(XCOFFRelocation32);
+    }
+  }
+
+  // Write symbols.
+  Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
+        Obj.FileHeader.SymbolTableOffset;
+  for (XCOFFSymbolEntry &Sym : Obj.Symbols) {
+    memcpy(Ptr, &Sym, sizeof(XCOFFSymbolEntry));
+    Ptr += sizeof(XCOFFSymbolEntry) * (1 + Sym.NumberOfAuxEntries);
+  }
+  Out.write(Buf->getBufferStart(), Buf->getBufferSize());
+  return Error::success();
+}
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm

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 CopyConfig;
+
+namespace xcoff {
+Error executeObjcopyOnBinary(const CopyConfig &Config,
+                             object::XCOFFObjectFile &In, raw_ostream &Out);
+
+} // end namespace xcoff
+} // end namespace objcopy
+} // end namespace llvm
+
+#endif // LLVM_TOOLS_LLVM_OBJCOPY_XCOFFOBJCOPY_H
 No newline at end of file

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 "CopyConfig.h"
+#include "Object.h"
+#include "Reader.h"
+#include "Writer.h"
+#include "llvm/Support/Errc.h"
+
+namespace llvm {
+namespace objcopy {
+namespace xcoff {
+
+using namespace object;
+
+static Error handleArgs(const CopyConfig &Config, Object &Obj) {
+  if (!Config.AddGnuDebugLink.empty() || Config.ExtractPartition ||
+      !Config.SplitDWO.empty() || !Config.SymbolsPrefix.empty() ||
+      !Config.AllocSectionsPrefix.empty() ||
+      Config.DiscardMode != DiscardType::None || Config.NewSymbolVisibility ||
+      !Config.AddSection.empty() || !Config.DumpSection.empty() ||
+      !Config.SymbolsToAdd.empty() || !Config.RPathToAdd.empty() ||
+      !Config.RPathToPrepend.empty() || !Config.RPathsToUpdate.empty() ||
+      !Config.InstallNamesToUpdate.empty() || !Config.RPathsToRemove.empty() ||
+      !Config.KeepSection.empty() || !Config.OnlySection.empty() ||
+      !Config.ToRemove.empty() || !Config.SymbolsToGlobalize.empty() ||
+      !Config.SymbolsToKeep.empty() || !Config.SymbolsToLocalize.empty() ||
+      !Config.SymbolsToRemove.empty() ||
+      !Config.UnneededSymbolsToRemove.empty() ||
+      !Config.SymbolsToWeaken.empty() || !Config.SymbolsToKeepGlobal.empty() ||
+      !Config.SectionsToRename.empty() || !Config.SetSectionAlignment.empty() ||
+      !Config.SetSectionFlags.empty() || !Config.SymbolsToRename.empty() ||
+      Config.AllowBrokenLinks || Config.ExtractDWO || Config.KeepFileSymbols ||
+      Config.ExtractMainPartition || Config.KeepUndefined ||
+      Config.OnlyKeepDebug || Config.LocalizeHidden || Config.PreserveDates ||
+      Config.StripAllGNU || Config.StripDWO || Config.StripDebug ||
+      Config.StripNonAlloc || Config.StripSections || Config.Weaken ||
+      Config.StripSwiftSymbols || Config.StripUnneeded ||
+      Config.DecompressDebugSections) {
+    return createStringError(
+        llvm::errc::invalid_argument,
+        "no flags are supported yet, only basic copying is allowed");
+  }
+  return Error::success();
+}
+
+Error executeObjcopyOnBinary(const CopyConfig &Config, 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

 //===- llvm-objcopy.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.h"
 #include "COFF/COFFObjcopy.h"
 #include "CopyConfig.h"
 #include "ELF/ELFObjcopy.h"
 #include "MachO/MachOObjcopy.h"
 #include "wasm/WasmObjcopy.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"
if (auto *ELFBinary = dyn_cast<object::ELFObjectFileBase>(&In)) {
     return coff::executeObjcopyOnBinary(Config, *COFFBinary, Out);
   else if (auto *MachOBinary = dyn_cast<object::MachOObjectFile>(&In))
     return macho::executeObjcopyOnBinary(Config, *MachOBinary, Out);
   else if (auto *MachOUniversalBinary =
                dyn_cast<object::MachOUniversalBinary>(&In))
     return macho::executeObjcopyOnMachOUniversalBinary(
         Config, *MachOUniversalBinary, Out);
   else if (auto *WasmBinary = dyn_cast<object::WasmObjectFile>(&In))
     return objcopy::wasm::executeObjcopyOnBinary(Config, *WasmBinary, Out);
+  else if (auto *XCOFFBinary = dyn_cast<object::XCOFFObjectFile>(&In))
+    return xcoff::executeObjcopyOnBinary(Config, *XCOFFBinary, Out);
   else
     return createStringError(object_error::invalid_file_type,
                              "unsupported object file format");
 }
 
 namespace llvm {
 namespace objcopy {