[yaml2obj/obj2yaml][MachO] Allow setting custom section data

[jhenderson]

Have you rebased recently? I feel like the content in yaml2macho.cpp may have moved to the ObjectYAML library recently.

llvm/lib/Object/MachOObjectFile.cpp

1948

A 32-bit Offset but 64-bit Size seems off to me. What are the limitations on the two fields in Mach-O's file format?

llvm/test/ObjectYAML/MachO/section_data.yaml

1

Probably worth a header comment summarizing the purpose of the test, e.g. "Show that yaml2obj supports custom section data for Mach-O YAML inputs."

3

Nit: add a blank line before the YAML.

40

Move the check before the yaml. Flow should be:

## Comment
# RUN:
# CHECK:
Yaml

## Comment
# RUN:
# CHECK:
Yaml

42

The size of content -> The content size

equals to -> equals

101

size of content -> content size

102

are filled -> is filled
by zero -> with zeroes

llvm/test/ObjectYAML/MachO/virtual_section.yaml

178

Why are these no longer CHECK-NEXT? Should you be testing the new stuff before it?

[abrachet]

Have you rebased recently? I feel like the content in yaml2macho.cpp may have moved to the ObjectYAML library recently.

I hadn't actually done that yet but just did so in rL368021

[seiya]

Addressed review comments.

[seiya]

llvm/lib/Object/MachOObjectFile.cpp

1948

This comes from the definition of struct section_64 [1].

[1]: https://github.com/opensource-apple/cctools/blob/master/include/mach-o/loader.h#L427-L428

llvm/test/ObjectYAML/MachO/virtual_section.yaml

178

I removed the -NEXT because the newly added content fields were lengthy but it was bad idea. I've replaced them with regular expressions instead.

llvm/tools/obj2yaml/macho2yaml.cpp

21

I'd like to move this function into somewhere else instead of copying from MachOEmitter.cpp but I couldn't locate the appropriate place. Any suggestions?

[alexander-shaposhnikov]

llvm/include/llvm/ObjectYAML/MachOYAML.h

203

khm, to be honest, I would not place it here , these template specializations provide the static method "mapping" only. Somehow, I don't see where this method ("validate") is being used at the moment - maybe we can either delete it or hide it inside MachOYAML.cpp

[jhenderson]

llvm/lib/ObjectYAML/MachOEmitter.cpp

322 ↗

(On Diff #214064)

Could you add the missing trailing full stop whilst you're here, please?

llvm/test/ObjectYAML/MachO/section_data.yaml

45

Delete the second "content".

llvm/tools/obj2yaml/macho2yaml.cpp

21

Two suggestions:

1. MachOYAML.cpp/.h
2. BinaryFormat/MachO.h (assuming it could be useful in a wider context).

[seiya]

Addressed review comments.

[seiya]

llvm/include/llvm/ObjectYAML/MachOYAML.h

203

validate is an optional method in MappingTraits and it's implemented in MachOYAML.cpp.

I think this should be here to validate obviously invalid input by YAMLTraits.h since it provides human-friendly error messages like:

YAML:30:9: error: Section size must be greater than or equal to the content size
      - sectname:        __data
        ^
yaml2obj: error: Failed to parse YAML input!

llvm/lib/ObjectYAML/MachOYAML.cpp

294

Here.

llvm/tools/obj2yaml/macho2yaml.cpp

21

Moved into the BinaryFormat/MachO.h. Thanks!

[jhenderson]

LGTM. You might want @alexshap to confirm before landing this though.

[alexander-shaposhnikov]

LG, thanks for working on this!

llvm/include/llvm/ObjectYAML/MachOYAML.h

203

fair enough

[seiya]

Rebase for the sake of arc patch.

llvm/include/llvm/Object/MachO.h

public:
   unsigned getSymbolSectionID(SymbolRef Symb) const;
   unsigned getSectionID(SectionRef Sec) const;
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
+  ArrayRef<uint8_t> getSectionContents(uint32_t Offset, uint64_t Size) const;
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   Expected<SectionRef> getSection(unsigned SectionIndex) const;
   Expected<SectionRef> getSection(StringRef SectionName) const;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;

llvm/include/llvm/ObjectYAML/MachOYAML.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_MACHOYAML_H
 #define LLVM_OBJECTYAML_MACHOYAML_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
+#include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace MachOYAML {
 
 struct Section {
   char sectname[16];
   char segname[16];
   llvm::yaml::Hex64 addr;
   uint64_t size;
   llvm::yaml::Hex32 offset;
   uint32_t align;
   llvm::yaml::Hex32 reloff;
   uint32_t nreloc;
   llvm::yaml::Hex32 flags;
   llvm::yaml::Hex32 reserved1;
   llvm::yaml::Hex32 reserved2;
   llvm::yaml::Hex32 reserved3;
+  Optional<llvm::yaml::BinaryRef> content;
 };
 
 struct FileHeader {
   llvm::yaml::Hex32 magic;
   llvm::yaml::Hex32 cputype;
   llvm::yaml::Hex32 cpusubtype;
   llvm::yaml::Hex32 filetype;
   uint32_t ncmds;

 };
 
 template <> struct MappingTraits<MachOYAML::ExportEntry> {
   static void mapping(IO &IO, MachOYAML::ExportEntry &ExportEntry);
 };
 
 template <> struct MappingTraits<MachOYAML::Section> {
   static void mapping(IO &IO, MachOYAML::Section &Section);
+  static StringRef validate(IO &io, MachOYAML::Section &Section);
 };
 
 template <> struct MappingTraits<MachOYAML::NListEntry> {
   static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry);
 };
 
 template <> struct MappingTraits<MachO::build_tool_version> {
   static void mapping(IO &IO, MachO::build_tool_version &tool);

llvm/lib/Object/MachOObjectFile.cpp

uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
   uint64_t FileSize = getData().size();
   if (SectOffset > FileSize)
     return 0;
   if (FileSize - SectOffset < SectSize)
     return FileSize - SectOffset;
   return SectSize;
 }
 
+ArrayRef<uint8_t> MachOObjectFile::getSectionContents(uint32_t Offset,
+                                                      uint64_t Size) const {
+  return arrayRefFromStringRef(getData().substr(Offset, Size));
+}
+
 Expected<ArrayRef<uint8_t>>
 MachOObjectFile::getSectionContents(DataRefImpl Sec) const {
   uint32_t Offset;
   uint64_t Size;
 
   if (is64Bit()) {
     MachO::section_64 Sect = getSection64(Sec);
     Offset = Sect.offset;
     Size = Sect.size;
   } else {
     MachO::section Sect = getSection(Sec);
     Offset = Sect.offset;
     Size = Sect.size;
   }
 
-  return arrayRefFromStringRef(getData().substr(Offset, Size));
+  return getSectionContents(Offset, Size);
 }
 
 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   uint32_t Align;
   if (is64Bit()) {
     MachO::section_64 Sect = getSection64(Sec);
     Align = Sect.align;
   } else {

llvm/lib/ObjectYAML/MachOYAML.cpp

void MappingTraits<MachOYAML::Section>::mapping(IO &IO,
   IO.mapRequired("offset", Section.offset);
   IO.mapRequired("align", Section.align);
   IO.mapRequired("reloff", Section.reloff);
   IO.mapRequired("nreloc", Section.nreloc);
   IO.mapRequired("flags", Section.flags);
   IO.mapRequired("reserved1", Section.reserved1);
   IO.mapRequired("reserved2", Section.reserved2);
   IO.mapOptional("reserved3", Section.reserved3);
+  IO.mapOptional("content", Section.content);
+}
+
+StringRef
+MappingTraits<MachOYAML::Section>::validate(IO &IO,
+                                            MachOYAML::Section &Section) {
+  if (Section.content && Section.size < Section.content->binary_size())
+    return "Section size must be greater than or equal to the content size";
+  return {};
 }
 
 void MappingTraits<MachO::build_tool_version>::mapping(
     IO &IO, MachO::build_tool_version &tool) {
   IO.mapRequired("tool", tool.tool);
   IO.mapRequired("version", tool.version);
 }
 

llvm/test/ObjectYAML/MachO/section_data.yaml

+## Case 1: The size of content is greater than the section size.
+# RUN: not yaml2obj --docnum=1 %s -o %t1 2>&1 | FileCheck %s --check-prefix=CASE1
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000001
+  ncmds:           1
+  sizeofcmds:      232
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         ''
+    vmaddr:          0
+    vmsize:          4
+    fileoff:         392
+    filesize:        4
+    maxprot:         7
+    initprot:        7
+    nsects:          1
+    flags:           0
+    Sections:
+      - sectname:        __data
+        segname:         __DATA
+        addr:            0x0000000000000000
+        size:            0
+        offset:          0x00000188
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         CDAB3412
+
+# CASE1: error: Section size must be greater than or equal to the content size
+
+## Case 2: The size of content equals to the section size.
+# RUN: yaml2obj --docnum=2 %s > %t2
+# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=CASE2
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000001
+  ncmds:           1
+  sizeofcmds:      232
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         ''
+    vmaddr:          0
+    vmsize:          4
+    fileoff:         392
+    filesize:        4
+    maxprot:         7
+    initprot:        7
+    nsects:          1
+    flags:           0
+    Sections:
+      - sectname:        __data
+        segname:         __DATA
+        addr:            0x0000000000000000
+        size:            4
+        offset:          0x00000188
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         CDAB3412
+
+# CASE2:       Index: 0
+# CASE2-NEXT:  Name: __data (5F 5F 64 61 74 61 00 00 00 00 00 00 00 00 00 00)
+# CASE2-NEXT:  Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
+# CASE2-NEXT:  Address: 0x0
+# CASE2-NEXT:  Size: 0x4
+# CASE2-NEXT:  Offset: 392
+# CASE2-NEXT:  Alignment: 2
+# CASE2-NEXT:  RelocationOffset: 0x0
+# CASE2-NEXT:  RelocationCount: 0
+# CASE2-NEXT:  Type: 0x0
+# CASE2-NEXT:  Attributes [ (0x0)
+# CASE2-NEXT:  ]
+# CASE2-NEXT:  Reserved1: 0x0
+# CASE2-NEXT:  Reserved2: 0x0
+# CASE2-NEXT:  Reserved3: 0x0
+# CASE2-NEXT:  SectionData (
+# CASE2-NEXT:    0000: CDAB3412                             |..4.|
+# CASE2-NEXT:  )
+
+## Case 3: The size of content is less than the section size. In this case, the area
+## after the custom content are filled by zero.
+# RUN: yaml2obj --docnum=3 %s > %t3
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=CASE3
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000001
+  ncmds:           1
+  sizeofcmds:      232
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         ''
+    vmaddr:          0
+    vmsize:          4
+    fileoff:         392
+    filesize:        4
+    maxprot:         7
+    initprot:        7
+    nsects:          1
+    flags:           0
+    Sections:
+      - sectname:        __data
+        segname:         __DATA
+        addr:            0x0000000000000000
+        size:            4
+        offset:          0x00000188
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         AA
+
+# CASE3:       Index: 0
+# CASE3-NEXT:  Name: __data (5F 5F 64 61 74 61 00 00 00 00 00 00 00 00 00 00)
+# CASE3-NEXT:  Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
+# CASE3-NEXT:  Address: 0x0
+# CASE3-NEXT:  Size: 0x4
+# CASE3-NEXT:  Offset: 392
+# CASE3-NEXT:  Alignment: 2
+# CASE3-NEXT:  RelocationOffset: 0x0
+# CASE3-NEXT:  RelocationCount: 0
+# CASE3-NEXT:  Type: 0x0
+# CASE3-NEXT:  Attributes [ (0x0)
+# CASE3-NEXT:  ]
+# CASE3-NEXT:  Reserved1: 0x0
+# CASE3-NEXT:  Reserved2: 0x0
+# CASE3-NEXT:  Reserved3: 0x0
+# CASE3-NEXT:  SectionData (
+# CASE3-NEXT:    0000: AA000000                             |....|
+# CASE3-NEXT:  )

llvm/test/ObjectYAML/MachO/virtual_section.yaml

StringTable:
     - _main
     - _d
     - _c
     - _b
     - _a
     - ''
 ...
 
-# CHECK:         Sections:
-# CHECK-NEXT:      - sectname:        __text
+# CHECK:           - sectname:        __text
 # CHECK-NEXT:        segname:         __TEXT
 # CHECK-NEXT:        addr:            0x0000000000000000
 # CHECK-NEXT:        size:            72
 # CHECK-NEXT:        offset:          0x000002B0
 # CHECK-NEXT:        align:           4
 # CHECK-NEXT:        reloff:          0x00000350
 # CHECK-NEXT:        nreloc:          7
 # CHECK-NEXT:        flags:           0x80000400
 # CHECK-NEXT:        reserved1:       0x00000000
 # CHECK-NEXT:        reserved2:       0x00000000
 # CHECK-NEXT:        reserved3:       0x00000000
-# CHECK-NEXT:      - sectname:        __data
+# CHECK:           - sectname:        __data
 # CHECK-NEXT:        segname:         __DATA
 # CHECK-NEXT:        addr:            0x0000000000000048
 # CHECK-NEXT:        size:            4
 # CHECK-NEXT:        offset:          0x000002F8
 # CHECK-NEXT:        align:           2
 # CHECK-NEXT:        reloff:          0x00000000
 # CHECK-NEXT:        nreloc:          0
 # CHECK-NEXT:        flags:           0x00000000
 # CHECK-NEXT:        reserved1:       0x00000000
 # CHECK-NEXT:        reserved2:       0x00000000
 # CHECK-NEXT:        reserved3:       0x00000000
-# CHECK-NEXT:      - sectname:        __bss
+# CHECK:           - sectname:        __bss
 # CHECK-NEXT:        segname:         __DATA
 # CHECK-NEXT:        addr:            0x00000000000000A0
 # CHECK-NEXT:        size:            8
 # CHECK-NEXT:        offset:          0x00000000
 # CHECK-NEXT:        align:           2
 # CHECK-NEXT:        reloff:          0x00000000
 # CHECK-NEXT:        nreloc:          0
 # CHECK-NEXT:        flags:           0x00000001
 # CHECK-NEXT:        reserved1:       0x00000000
 # CHECK-NEXT:        reserved2:       0x00000000
 # CHECK-NEXT:        reserved3:       0x00000000
-# CHECK-NEXT:      - sectname:        __thread_bss
+# CHECK:           - sectname:        __thread_bss
 # CHECK-NEXT:        segname:         __DATA
 # CHECK-NEXT:        addr:            0x00000000000000A8
 # CHECK-NEXT:        size:            7
 # CHECK-NEXT:        offset:          0x00000000
 # CHECK-NEXT:        align:           0
 # CHECK-NEXT:        reloff:          0x00000000
 # CHECK-NEXT:        nreloc:          0
 # CHECK-NEXT:        flags:           0x00000012
 # CHECK-NEXT:        reserved1:       0x00000000
 # CHECK-NEXT:        reserved2:       0x00000000
 # CHECK-NEXT:        reserved3:       0x00000000
-# CHECK-NEXT:      - sectname:        __thread_vars
+# CHECK:           - sectname:        __thread_vars
 # CHECK-NEXT:        segname:         __DATA
 # CHECK-NEXT:        addr:            0x000000000000004C
 # CHECK-NEXT:        size:            12
 # CHECK-NEXT:        offset:          0x000002FC
 # CHECK-NEXT:        align:           0
 # CHECK-NEXT:        reloff:          0x00000388
 # CHECK-NEXT:        nreloc:          2
 # CHECK-NEXT:        flags:           0x00000013
 # CHECK-NEXT:        reserved1:       0x00000000
 # CHECK-NEXT:        reserved2:       0x00000000
 # CHECK-NEXT:        reserved3:       0x00000000

llvm/tools/obj2yaml/macho2yaml.cpp

 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 
 #include <string.h> // for memcpy
 
 using namespace llvm;
 
 class MachODumper {
 
   template <typename StructType>
   const char *processLoadCommandData(
       MachOYAML::LoadCommand &LC,
       const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd);
 
   const object::MachOObjectFile &Obj;
   void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes,
                        ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false);
   void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpDebugAbbrev(DWARFContext &DCtx,
                        std::unique_ptr<MachOYAML::Object> &Y);
   void dumpDebugStrings(DWARFContext &DCtx,
                         std::unique_ptr<MachOYAML::Object> &Y);
 
+  template <typename SectionType>
+  MachOYAML::Section constructSectionCommon(SectionType Sec);
+  template <typename SectionType>
+  MachOYAML::Section constructSection(SectionType Sec);
+  template <typename SectionType, typename SegmentType>
+  const char *
+  extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+                  std::vector<MachOYAML::Section> &Sections);
+
 public:
   MachODumper(const object::MachOObjectFile &O) : Obj(O) {}
   Expected<std::unique_ptr<MachOYAML::Object>> dump();
 };
 
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
-    memcpy((void *) & (LC.Data.LCStruct##_data), LoadCmd.Ptr,                  \
+    memcpy((void *)&(LC.Data.LCStruct##_data), LoadCmd.Ptr,                    \
            sizeof(MachO::LCStruct));                                           \
     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)                       \
       MachO::swapStruct(LC.Data.LCStruct##_data);                              \
     EndPtr = processLoadCommandData<MachO::LCStruct>(LC, LoadCmd);             \
     break;
 
 template <typename SectionType>
-MachOYAML::Section constructSectionCommon(SectionType Sec) {
+MachOYAML::Section MachODumper::constructSectionCommon(SectionType Sec) {
   MachOYAML::Section TempSec;
   memcpy(reinterpret_cast<void *>(&TempSec.sectname[0]), &Sec.sectname[0], 16);
   memcpy(reinterpret_cast<void *>(&TempSec.segname[0]), &Sec.segname[0], 16);
   TempSec.addr = Sec.addr;
   TempSec.size = Sec.size;
   TempSec.offset = Sec.offset;
   TempSec.align = Sec.align;
   TempSec.reloff = Sec.reloff;
   TempSec.nreloc = Sec.nreloc;
   TempSec.flags = Sec.flags;
   TempSec.reserved1 = Sec.reserved1;
   TempSec.reserved2 = Sec.reserved2;
   TempSec.reserved3 = 0;
+  TempSec.content =
+      yaml::BinaryRef(Obj.getSectionContents(Sec.offset, Sec.size));
   return TempSec;
 }
 
-template <typename SectionType>
-MachOYAML::Section constructSection(SectionType Sec);
-
-template <> MachOYAML::Section constructSection(MachO::section Sec) {
+template <>
+MachOYAML::Section MachODumper::constructSection(MachO::section Sec) {
   MachOYAML::Section TempSec = constructSectionCommon(Sec);
   TempSec.reserved3 = 0;
   return TempSec;
 }
 
-template <> MachOYAML::Section constructSection(MachO::section_64 Sec) {
+template <>
+MachOYAML::Section MachODumper::constructSection(MachO::section_64 Sec) {
   MachOYAML::Section TempSec = constructSectionCommon(Sec);
   TempSec.reserved3 = Sec.reserved3;
   return TempSec;
 }
 
 template <typename SectionType, typename SegmentType>
-const char *
-extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
-                std::vector<MachOYAML::Section> &Sections,
-                bool IsLittleEndian) {
+const char *MachODumper::extractSections(
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    std::vector<MachOYAML::Section> &Sections) {
   auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize;
   const SectionType *Curr =
       reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType));
   for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
-    if (IsLittleEndian != sys::IsLittleEndianHost) {
+    if (Obj.isLittleEndian() != sys::IsLittleEndianHost) {
       SectionType Sec;
       memcpy((void *)&Sec, Curr, sizeof(SectionType));
       MachO::swapStruct(Sec);
       Sections.push_back(constructSection(Sec));
     } else {
       Sections.push_back(constructSection(*Curr));
     }
   }
   return reinterpret_cast<const char *>(Curr);
 }
 
 template <typename StructType>
 const char *MachODumper::processLoadCommandData(
     MachOYAML::LoadCommand &LC,
     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
   return LoadCmd.Ptr + sizeof(StructType);
 }
 
 template <>
 const char *MachODumper::processLoadCommandData<MachO::segment_command>(
     MachOYAML::LoadCommand &LC,
     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
-  return extractSections<MachO::section, MachO::segment_command>(
-      LoadCmd, LC.Sections, Obj.isLittleEndian());
+  return extractSections<MachO::section, MachO::segment_command>(LoadCmd,
+                                                                 LC.Sections);
 }
 
 template <>
 const char *MachODumper::processLoadCommandData<MachO::segment_command_64>(
     MachOYAML::LoadCommand &LC,
     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
   return extractSections<MachO::section_64, MachO::segment_command_64>(
-      LoadCmd, LC.Sections, Obj.isLittleEndian());
+      LoadCmd, LC.Sections);
 }
 
 template <typename StructType>
 const char *
 readString(MachOYAML::LoadCommand &LC,
            const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
   auto Start = LoadCmd.Ptr + sizeof(StructType);
   auto MaxSize = LoadCmd.C.cmdsize - sizeof(StructType);

llvm/tools/yaml2obj/yaml2macho.cpp

case MachO::LC_SEGMENT_64:
 
           continue;
         }
 
         // Skip if it's a virtual section.
         if (isVirtualSection(Sec.flags & MachO::SECTION_TYPE))
           continue;
 
+        if (Sec.content) {
+          yaml::BinaryRef Content = *Sec.content;
+          Content.writeAsBinary(OS);
+          ZeroFillBytes(OS, Sec.size - Content.binary_size());
+        } else {
           // Fill section data with 0xDEADBEEF
           Fill(OS, Sec.size, 0xDEADBEEFu);
         }
+      }
       uint64_t segSize = is64Bit ? LC.Data.segment_command_64_data.filesize
                                  : LC.Data.segment_command_data.filesize;
       ZeroToOffset(OS, segOff + segSize);
       break;
     }
   }
   // Old PPC Object Files didn't have __LINKEDIT segments, the data was just
   // stuck at the end of the file.