[llvm-lipo] Implement -create part 1

[anushabasana]

Summary

Creates universal binary output file from input files. Currently uses hard coded value for alignment.
Want to get the create functionality approved before implementing the alignment function.

Test Plan: check-llvm

[anushabasana]

@mtrent We have implemented create with the -fat64 flag to specify a fat64binary, similar to cctools lipo.
Do we still need this flag, or can we always create a fat64 binary?
Another option would be to have some sort of auto detection to create a fat64 binary when the offset of a section exceeds 32 bits.

[compnerd]

llvm/tools/llvm-lipo/llvm-lipo.cpp

274

I think that this can be replaced with a range based loop:

for (auto O : UO->objects()) {
  Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError = O.getAsObjectFile();
  if (!BinaryOrError)
    reportError(InputBinary->getFileName(), BinaryOrError.takeError());
  outs() << getArchString(BinaryOrError.get()->get()) << “ “;
}

329

I think that having a helper will help:

auto CPUIDForSlice = [](const Slice &S) -> uint64_t {
  return S.ObjectFile->getHeader().cputype << 32 | S.ObjectFile->getHeader().cpusubtype;
};

404

I think that it is better to return a SmallVectorImpl<FatArchType>

[alexander-shaposhnikov]

llvm/tools/llvm-lipo/llvm-lipo.cpp

404

i think no, this would cause "slicing", SmallVector has 2 immediate bases (nonempty) https://llvm.org/doxygen/SmallVector_8h_source.html#837

[mtrent]

In D64102#1567303, @anushabasana wrote:

@mtrent We have implemented create with the -fat64 flag to specify a fat64binary, similar to cctools lipo.
Do we still need this flag, or can we always create a fat64 binary?
Another option would be to have some sort of auto detection to create a fat64 binary when the offset of a section exceeds 32 bits.

Support for fat64 is still largely experimental, and the -fat64 flag is intentionally undocumented. I suggest omitting it from llvm for now, in case we decide the implementation needs to change before we roll the feature out ourselves. Otherwise, you run the risk of forking the Mach-O file format, which would be ... unfortunate.

[smeenai]

llvm/tools/llvm-lipo/llvm-lipo.cpp

329

I think you'd still need to cast S.ObjectFile->getHeader().cputype to a uint64_t beforehand, otherwise you'll be shifting an int by 32 bits and get UB.

[anushabasana]

Removed fat64 flag and addressed other review comments.

[alexander-shaposhnikov]

I've added a couple of minor comments, but other than that - looks good to me) I'd wait for @mtrent 's approval as well

llvm/tools/llvm-lipo/llvm-lipo.cpp

258

const Triple

274

for (const auto &O : ... )

[alexander-shaposhnikov]

llvm/tools/llvm-lipo/llvm-lipo.cpp

443

nit: const uint64_t

[alexander-shaposhnikov]

llvm/tools/llvm-lipo/llvm-lipo.cpp

387

I'd rename I -> O:

for (const auto &O : UO->objects())

[smeenai]

llvm/tools/llvm-lipo/llvm-lipo.cpp

331

Nit: you shouldn't need the -> uint64_t; the return type should be inferred correctly.

336

Nit: you could use try_emplace instead of insert to avoid the need for std::make_pair.

419

Nit: I'd add a newline above this, to separate the error handling from the normal codepath.

[anushabasana]

Addressed minor review comments

[anushabasana]

Updated alignment hardcoding

[anushabasana]

llvm/tools/llvm-lipo/llvm-lipo.cpp

360

@mtrent The alignment for all of the valid architectures falls under the hard coded segment above. Is it still useful to implement the calculateAlignment function by segments for unknown architecture types?

[anushabasana]

• [llvm-lipo] Implement -info

[anushabasana]

Revert last update, was a mistake

llvm/test/tools/llvm-lipo/Inputs/arm64-slice.yaml

+--- !mach-o
+FileHeader:      
+  magic:           0xFEEDFACF
+  cputype:         0x0100000C
+  cpusubtype:      0x00000000
+  filetype:        0x00000001
+  ncmds:           4
+  sizeofcmds:      352
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:    
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         ''
+    vmaddr:          0
+    vmsize:          56
+    fileoff:         384
+    filesize:        56
+    maxprot:         7
+    initprot:        7
+    nsects:          2
+    flags:           0
+    Sections:        
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000000000000
+        size:            20
+        offset:          0x00000180
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+      - sectname:        __compact_unwind
+        segname:         __LD
+        addr:            0x0000000000000018
+        size:            32
+        offset:          0x00000198
+        align:           3
+        reloff:          0x000001B8
+        nreloc:          1
+        flags:           0x02000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+  - cmd:             LC_VERSION_MIN_IPHONEOS
+    cmdsize:         16
+    version:         327680
+    sdk:             0
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          448
+    nsyms:           3
+    stroff:          496
+    strsize:         20
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       2
+    iextdefsym:      2
+    nextdefsym:      1
+    iundefsym:       3
+    nundefsym:       0
+    tocoff:          0
+    ntoc:            0
+    modtaboff:       0
+    nmodtab:         0
+    extrefsymoff:    0
+    nextrefsyms:     0
+    indirectsymoff:  0
+    nindirectsyms:   0
+    extreloff:       0
+    nextrel:         0
+    locreloff:       0
+    nlocrel:         0
+LinkEditData:    
+  NameList:        
+    - n_strx:          13
+      n_type:          0x0E
+      n_sect:          1
+      n_desc:          0
+      n_value:         0
+    - n_strx:          7
+      n_type:          0x0E
+      n_sect:          2
+      n_desc:          0
+      n_value:         24
+    - n_strx:          1
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          0
+      n_value:         0
+  StringTable:     
+    - ''
+    - _main
+    - ltmp1
+    - ltmp0
+    - ''
+...

llvm/test/tools/llvm-lipo/Inputs/armv7-slice.yaml

+--- !mach-o
+FileHeader:      
+  magic:           0xFEEDFACE
+  cputype:         0x0000000C
+  cpusubtype:      0x00000009
+  filetype:        0x00000001
+  ncmds:           4
+  sizeofcmds:      244
+  flags:           0x00002000
+LoadCommands:    
+  - cmd:             LC_SEGMENT
+    cmdsize:         124
+    segname:         ''
+    vmaddr:          0
+    vmsize:          10
+    fileoff:         272
+    filesize:        10
+    maxprot:         7
+    initprot:        7
+    nsects:          1
+    flags:           0
+    Sections:        
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000000000000
+        size:            10
+        offset:          0x00000110
+        align:           1
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+  - cmd:             LC_VERSION_MIN_IPHONEOS
+    cmdsize:         16
+    version:         327680
+    sdk:             0
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          284
+    nsyms:           1
+    stroff:          296
+    strsize:         8
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       0
+    iextdefsym:      0
+    nextdefsym:      1
+    iundefsym:       1
+    nundefsym:       0
+    tocoff:          0
+    ntoc:            0
+    modtaboff:       0
+    nmodtab:         0
+    extrefsymoff:    0
+    nextrefsyms:     0
+    indirectsymoff:  0
+    nindirectsyms:   0
+    extreloff:       0
+    nextrel:         0
+    locreloff:       0
+    nlocrel:         0
+LinkEditData:    
+  NameList:        
+    - n_strx:          1
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          8
+      n_value:         0
+  StringTable:     
+    - ''
+    - _main
+    - ''
+...

llvm/test/tools/llvm-lipo/Inputs/x86_64-slice.yaml

+--- !mach-o
+FileHeader:      
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000001
+  ncmds:           4
+  sizeofcmds:      352
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:    
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         ''
+    vmaddr:          0
+    vmsize:          80
+    fileoff:         384
+    filesize:        80
+    maxprot:         7
+    initprot:        7
+    nsects:          2
+    flags:           0
+    Sections:        
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000000000000
+        size:            15
+        offset:          0x00000180
+        align:           4
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+      - sectname:        __eh_frame
+        segname:         __TEXT
+        addr:            0x0000000000000010
+        size:            64
+        offset:          0x00000190
+        align:           3
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x6800000B
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+  - cmd:             LC_VERSION_MIN_MACOSX
+    cmdsize:         16
+    version:         656384
+    sdk:             0
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          464
+    nsyms:           1
+    stroff:          480
+    strsize:         8
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       0
+    iextdefsym:      0
+    nextdefsym:      1
+    iundefsym:       1
+    nundefsym:       0
+    tocoff:          0
+    ntoc:            0
+    modtaboff:       0
+    nmodtab:         0
+    extrefsymoff:    0
+    nextrefsyms:     0
+    indirectsymoff:  0
+    nindirectsyms:   0
+    extreloff:       0
+    nextrel:         0
+    locreloff:       0
+    nlocrel:         0
+LinkEditData:    
+  NameList:        
+    - n_strx:          1
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          0
+      n_value:         0
+  StringTable:     
+    - ''
+    - _main
+    - ''
+...

llvm/test/tools/llvm-lipo/create-executable.test

+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-i386.o
+# RUN: yaml2obj %p/Inputs/x86_64-slice.yaml > %t-x86_64.o
+
+# RUN: chmod -x %t-i386.o
+# RUN: chmod -x %t-x86_64.o
+# RUN: llvm-lipo %t-i386.o %t-x86_64.o -create -output %t-universal.o
+# RUN: ! test -x %t-universal.o
+
+# RUN: chmod +x %t-i386.o
+# RUN: llvm-lipo %t-i386.o %t-x86_64.o -create -output %t-universal.o
+# RUN: test -x %t-universal.o

llvm/test/tools/llvm-lipo/create-fat64.test

+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-i386.o
+# RUN: yaml2obj %p/Inputs/x86_64-slice.yaml > %t-x86_64.o
+
+# RUN: llvm-lipo %t-i386.o %t-x86_64.o -create -output %t-universal.o -fat64
+
+# RUN: llvm-objdump %t-universal.o -m --universal-headers | FileCheck %s
+# CHECK: fat_magic FAT_MAGIC_64
+
+# RUN: llvm-lipo %t-universal.o -thin x86_64 -output %t-x86_64_extracted.o
+# RUN: cmp %t-x86_64.o %t-x86_64_extracted.o

llvm/test/tools/llvm-lipo/create-invalid-input.test

+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-32.o
+# RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml > %t-universal.o
+
+# RUN: not llvm-lipo %t-32.o -create 2>&1 | FileCheck --check-prefix=NO_OUTPUT %s
+# NO_OUTPUT: error: create expects a single output file to be specified
+
+# RUN: not llvm-lipo %t-universal.o %t-32.o -create -output %t.o 2>&1 | FileCheck --check-prefix=DUPLICATE_ARCHS %s
+# DUPLICATE_ARCHS: have the same architecture i386 and therefore cannot be in the same universal binary

llvm/test/tools/llvm-lipo/create-without-alignment.test

+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-i386.o
+# RUN: yaml2obj %p/Inputs/x86_64-slice.yaml > %t-x86_64.o
+
+# RUN: llvm-lipo %t-i386.o %t-x86_64.o -create -output %t-universal-llvm.o
+
+# RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml > %t-universal.o
+# RUN: cmp %t-universal-llvm.o %t-universal.o
+
+# RUN: yaml2obj %p/Inputs/armv7-slice.yaml > %t-armv7.o
+# RUN: yaml2obj %p/Inputs/arm64-slice.yaml > %t-arm64.o
+
+# RUN: llvm-lipo %t-arm64.o %t-armv7.o %t-universal.o -create -output %t-universal-2.o
+# RUN: llvm-lipo %t-universal-2.o -thin x86_64 -output %t-x86_64_extracted.o
+# RUN: cmp %t-x86_64_extracted.o %t-x86_64.o
+# RUN: llvm-lipo %t-universal-2.o -thin armv7 -output %t-armv7-extracted.o
+# RUN: cmp %t-armv7-extracted.o %t-armv7.o
+
+# RUN: llvm-objdump %t-universal-2.o -m --universal-headers | FileCheck %s
+# CHECK: fat_magic FAT_MAGIC
+# CHECK: nfat_arch 4
+# CHECK: architecture i386
+# CHECK: offset 4096
+# CHECK: align 2^12 (4096)
+# CHECK: architecture x86_64
+# CHECK: offset 8192
+# CHECK: align 2^12 (4096)
+# CHECK: architecture armv7
+# CHECK: offset 16384
+# CHECK: align 2^14 (16384)
+# CHECK: architecture arm64
+# CHECK: offset 32768
+# CHECK: align 2^14 (16384)

llvm/test/tools/llvm-lipo/thin-executable-universal-binary.test

 # Executable testing is not supported on Windows, since all files are considered executable
 # UNSUPPORTED: system-windows
 # RUN: yaml2obj %s > %t-universal.o
 
 # RUN: chmod -x %t-universal.o
 # RUN: llvm-lipo %t-universal.o -thin i386 -output %t32.o
-# RUN: test ! -x %t32.o
+# RUN: ! test -x %t32.o
 
 # RUN: chmod +x %t-universal.o
 # RUN: llvm-lipo %t-universal.o -thin i386 -output %t32-ex.o
 # RUN: test -x %t32-ex.o
 
 
 
 --- !fat-mach-o

llvm/tools/llvm-lipo/LipoOpts.td

 include "llvm/Option/OptParser.td"
 
 def help : Flag<["-", "--"], "help">;
 def h : Flag<["-"], "h">, Alias<help>;
 
 def version : Flag<["-", "--"], "version">,
               HelpText<"Print the version and exit.">;
 
+def fat64 : Flag<["-", "--"], "fat64">,
+            HelpText<"Create a 64-bit universal binary output file.">;
+
 def action_group : OptionGroup<"action group">;
 
 def verify_arch
     : Option<["-", "--"], "verify_arch", KIND_REMAINING_ARGS>,
       Group<action_group>,
       HelpText<
           "Verify that the specified arch_types are present in the input file">;
 
 def archs : Option<["-", "--"], "archs", KIND_FLAG>,
             Group<action_group>,
             HelpText<"Display the arch_types present in the input file">;
 
 def thin : Option<["-", "--"], "thin", KIND_SEPARATE>,
            Group<action_group>,
            HelpText<"Create a thin output file of specified arch_type from the "
                     "fat input file. Requires -output option">;
 
+def create : Option<["-", "--"], "create", KIND_FLAG>,
+             Group<action_group>,
+             HelpText<"Create a universal binary output file from the input "
+                      "files. Requires -output option">;
+
 def output : Option<["-", "--"], "output", KIND_SEPARATE>,
              HelpText<"Create output file with specified name">;
 def o : JoinedOrSeparate<["-"], "o">, Alias<output>;

llvm/tools/llvm-lipo/llvm-lipo.cpp

 public:
   LipoOptTable() : OptTable(LipoInfoTable) {}
 };
 
 enum class LipoAction {
   PrintArchs,
   VerifyArch,
   ThinArch,
+  CreateUniversal,
 };
 
 struct Config {
   SmallVector<std::string, 1> InputFiles;
   SmallVector<std::string, 1> VerifyArchList;
   std::string ThinArchType;
   std::string OutputFile;
   LipoAction ActionToPerform;
+  bool Is64Bit;
+};
+
+struct Slice {
+  const MachOObjectFile *ObjectFile;
+  // Requires Alignment field to store slice alignment values from universal
+  // binaries. Also needed to order the slices using compareSlices, so the total
+  // file size can be calculated before creating the output buffer.
+  uint32_t Alignment;
 };
 
 } // end namespace
 
 static void validateArchitectureName(StringRef ArchitectureName) {
   if (Triple(ArchitectureName).getArch() == Triple::ArchType::UnknownArch)
     reportError("Invalid architecture: " + ArchitectureName);
 }
 
 static Config parseLipoOptions(ArrayRef<const char *> ArgsArr) {
   Config C;
   LipoOptTable T;
   unsigned MissingArgumentIndex, MissingArgumentCount;
-  llvm::opt::InputArgList InputArgs =
+  opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 
   if (MissingArgumentCount)
     reportError("missing argument to " +
                 StringRef(InputArgs.getArgString(MissingArgumentIndex)) +
                 " option");
 
   if (InputArgs.size() == 0) {
static Config parseLipoOptions(ArrayRef<const char *> ArgsArr) {
   }
 
   if (InputArgs.hasArg(LIPO_version)) {
     outs() << ToolName + "\n";
     cl::PrintVersionMessage();
     exit(EXIT_SUCCESS);
   }
 
+  C.Is64Bit = InputArgs.hasArg(LIPO_fat64);
+
   for (auto Arg : InputArgs.filtered(LIPO_UNKNOWN))
     reportError("unknown argument '" + Arg->getAsString(InputArgs) + "'");
 
   for (auto Arg : InputArgs.filtered(LIPO_INPUT))
     C.InputFiles.push_back(Arg->getValue());
   if (C.InputFiles.empty())
     reportError("at least one input file should be specified");
 
case LIPO_thin:
     C.ThinArchType = ActionArgs[0]->getValue();
     validateArchitectureName(C.ThinArchType);
     if (C.OutputFile.empty())
       reportError("thin expects a single output file");
 
     C.ActionToPerform = LipoAction::ThinArch;
     return C;
 
+  case LIPO_create:
+    if (C.OutputFile.empty())
+      reportError("create expects a single output file to be specified");
+    C.ActionToPerform = LipoAction::CreateUniversal;
+    return C;
+
   default:
     reportError("llvm-lipo action unspecified");
   }
 }
 
 static SmallVector<OwningBinary<Binary>, 1>
 readInputBinaries(ArrayRef<std::string> InputFiles) {
   SmallVector<OwningBinary<Binary>, 1> InputBinaries;
   for (StringRef InputFile : InputFiles) {
-    Expected<OwningBinary<llvm::object::Binary>> BinaryOrErr =
-        createBinary(InputFile);
+    Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(InputFile);
     if (!BinaryOrErr)
       reportError(InputFile, BinaryOrErr.takeError());
     // TODO: Add compatibility for archive files
     if (BinaryOrErr->getBinary()->isArchive())
       reportError("File " + InputFile +
                   " is an archive file and is not yet supported.");
     if (!BinaryOrErr->getBinary()->isMachO() &&
         !BinaryOrErr->getBinary()->isMachOUniversalBinary())
for (StringRef Arch : VerifyArchList)
       if (ObjectArch != Triple(Arch).getArch())
         exit(EXIT_FAILURE);
   } else {
     llvm_unreachable("Unexpected binary format");
   }
   exit(EXIT_SUCCESS);
 }
 
-static void printArchOrUnknown(const MachOObjectFile *ObjectFile) {
-  // Prints trailing space and unknown in this format for compatibility with
-  // cctools lipo.
-  const std::string ObjectArch = ObjectFile->getArchTriple().getArchName();
-  if (ObjectArch.empty())
-    outs() << "unknown(" << ObjectFile->getHeader().cputype << ","
-           << ObjectFile->getHeader().cpusubtype << ") ";
-  else
-    outs() << ObjectArch + " ";
+// Returns a string of the given Object file's architecture type
+// Unknown architectures formatted unknown(CPUType,CPUSubType) for compatibility
+// with cctools lipo
+static std::string getArchString(const MachOObjectFile &ObjectFile) {
+  Triple T = ObjectFile.getArchTriple();
+  const StringRef ObjectArch = T.getArchName();
+  if (!ObjectArch.empty())
+    return ObjectArch;
+  return ("unknown(" + Twine(ObjectFile.getHeader().cputype) + "," +
+          Twine(ObjectFile.getHeader().cpusubtype & ~MachO::CPU_SUBTYPE_MASK) +
+          ")")
+      .str();
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void printArchs(ArrayRef<OwningBinary<Binary>> InputBinaries) {
+  // Prints trailing space for compatibility with cctools lipo.
   assert(InputBinaries.size() == 1 && "Incorrect number of input binaries");
   const Binary *InputBinary = InputBinaries.front().getBinary();
   if (auto UO = dyn_cast<MachOUniversalBinary>(InputBinary)) {
-    for (MachOUniversalBinary::object_iterator I = UO->begin_objects(),
-                                               E = UO->end_objects();
-         I != E; ++I) {
+    for (auto I = UO->begin_objects(), E = UO->end_objects(); I != E; ++I) {
       Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
           I->getAsObjectFile();
       if (!BinaryOrError)
         reportError(InputBinary->getFileName(), BinaryOrError.takeError());
-      printArchOrUnknown(BinaryOrError.get().get());
+      outs() << getArchString(*BinaryOrError.get().get()) << " ";
     }
   } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
-    printArchOrUnknown(O);
+    outs() << getArchString(*O) << " ";
   } else {
     llvm_unreachable("Unexpected binary format");
   }
 
   outs() << "\n";
   exit(EXIT_SUCCESS);
 }
 
static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
   std::copy(Obj.get()->getMemoryBufferRef().getBufferStart(),
             Obj.get()->getMemoryBufferRef().getBufferEnd(),
             OutFileOrError.get()->getBufferStart());
   if (Error E = OutFileOrError.get()->commit())
     reportError(OutputFileName, std::move(E));
   exit(EXIT_SUCCESS);
 }
 
+static void checkArchDuplicates(const ArrayRef<Slice> &Slices) {
+  DenseMap<uint64_t, const MachOObjectFile *> CPUIds;
+  for (const auto &S : Slices) {
+    uint64_t CPUPair = static_cast<uint64_t>(S.ObjectFile->getHeader().cputype)
+                           << 32 |
+                       S.ObjectFile->getHeader().cpusubtype;
+    auto Entry = CPUIds.insert(std::make_pair(CPUPair, S.ObjectFile));
+    if (!Entry.second)
+      reportError(Entry.first->second->getFileName() + " and " +
+                  S.ObjectFile->getFileName() + " have the same architecture " +
+                  getArchString(*S.ObjectFile) +
+                  " and therefore cannot be in the same universal binary");
+  }
+}
+
+static uint32_t calculateAlignment(const MachOObjectFile *ObjectFile) {
+  // TODO: Implement getAlign() and remove hard coding
+  // Will be implemented in a follow-up.
+
+  // ARM alignment of 14 for compatibility with cctools lipo
+  switch (ObjectFile->getHeader().cputype) {
+  case MachO::CPU_TYPE_ARM:
+  case MachO::CPU_TYPE_ARM64:
+  case MachO::CPU_TYPE_ARM64_32:
+    return 14;
+  default:
+    return 12;
+  }
+}
+
+// This function replicates ordering from cctools lipo for consistency
+static bool compareSlices(const Slice &Lhs, const Slice &Rhs) {
+  if (Lhs.ObjectFile->getHeader().cputype ==
+      Rhs.ObjectFile->getHeader().cputype)
+    return Lhs.ObjectFile->getHeader().cpusubtype <
+           Rhs.ObjectFile->getHeader().cpusubtype;
+
+  // force arm64-family to follow after all other slices for compatibility
+  // with cctools lipo
+  if (Lhs.ObjectFile->getHeader().cputype == MachO::CPU_TYPE_ARM64)
+    return false;
+  if (Rhs.ObjectFile->getHeader().cputype == MachO::CPU_TYPE_ARM64)
+    return true;
+
+  // Sort by alignment to minimize file size
+  return Lhs.Alignment < Rhs.Alignment;
+}
+
+// Updates vector ExtractedObjects with the MachOObjectFiles extracted from
+// Universal Binary files to transfer ownership.
+static SmallVector<Slice, 2> buildSlices(
+    ArrayRef<OwningBinary<Binary>> InputBinaries,
+    SmallVectorImpl<std::unique_ptr<MachOObjectFile>> &ExtractedObjects) {
+  SmallVector<Slice, 2> Slices;
+  for (auto &IB : InputBinaries) {
+    const Binary *InputBinary = IB.getBinary();
+    if (auto UO = dyn_cast<MachOUniversalBinary>(InputBinary)) {
+      for (const auto &I : UO->objects()) {
+        Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
+            I.getAsObjectFile();
+        if (!BinaryOrError)
+          reportError(InputBinary->getFileName(), BinaryOrError.takeError());
+        ExtractedObjects.push_back(std::move(BinaryOrError.get()));
+        Slices.push_back(Slice{ExtractedObjects.back().get(), I.getAlign()});
+      }
+    } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
+      Slices.push_back(Slice{O, calculateAlignment(O)});
+    } else {
+      llvm_unreachable("Unexpected binary format");
+    }
+  }
+  return Slices;
+}
+
+template <class FatArchType>
+static SmallVector<FatArchType, 2> buildFatArchList(ArrayRef<Slice> Slices) {
+  SmallVector<FatArchType, 2> FatArchList;
+  constexpr bool Is64Bit = std::is_same<FatArchType, MachO::fat_arch_64>::value;
+  uint64_t Offset =
+      sizeof(MachO::fat_header) + Slices.size() * sizeof(FatArchType);
+
+  for (size_t Index = 0, Size = Slices.size(); Index < Size; ++Index) {
+    Offset = alignTo(Offset, 1 << Slices[Index].Alignment);
+    const MachOObjectFile *ObjectFile = Slices[Index].ObjectFile;
+    if (!Is64Bit && Offset > UINT32_MAX)
+      reportError("fat file too large to be created because the offset "
+                  "field in struct fat_arch is only 32-bits and the offset " +
+                  Twine(Offset) + " for " + ObjectFile->getFileName() +
+                  " for architecture " + getArchString(*ObjectFile) +
+                  "exceeds that. Use -fat64 flag to expand the offset field to "
+                  "64-bits");
+    FatArchType FatArch;
+    FatArch.cputype = ObjectFile->getHeader().cputype;
+    FatArch.cpusubtype = ObjectFile->getHeader().cpusubtype;
+    FatArch.offset = Offset;
+    FatArch.size = ObjectFile->getMemoryBufferRef().getBufferSize();
+    FatArch.align = Slices[Index].Alignment;
+    Offset += FatArch.size;
+    FatArchList.push_back(FatArch);
+  }
+  return FatArchList;
+}
+
+template <class FatArchType>
+static void createUniversalBinary(SmallVectorImpl<Slice> &Slices,
+                                  StringRef OutputFileName) {
+  MachO::fat_header FatHeader;
+  constexpr bool Is64Bit = std::is_same<FatArchType, MachO::fat_arch_64>::value;
+  FatHeader.magic = Is64Bit ? MachO::FAT_MAGIC_64 : MachO::FAT_MAGIC;
+  FatHeader.nfat_arch = Slices.size();
+
+  stable_sort(Slices, compareSlices);
+  SmallVector<FatArchType, 2> FatArchList =
+      buildFatArchList<FatArchType>(Slices);
+
+  const bool IsExecutable = any_of(Slices, [](Slice S) {
+    return sys::fs::can_execute(S.ObjectFile->getFileName());
+  });
+  uint64_t OutputFileSize = FatArchList.back().offset + FatArchList.back().size;
+  Expected<std::unique_ptr<FileOutputBuffer>> OutFileOrError =
+      FileOutputBuffer::create(OutputFileName, OutputFileSize,
+                               IsExecutable ? FileOutputBuffer::F_executable
+                                            : 0);
+  if (!OutFileOrError)
+    reportError(OutputFileName, OutFileOrError.takeError());
+  std::unique_ptr<FileOutputBuffer> OutFile = std::move(OutFileOrError.get());
+  std::memset(OutFile->getBufferStart(), 0, OutputFileSize);
+
+  if (sys::IsLittleEndianHost)
+    MachO::swapStruct(FatHeader);
+  std::memcpy(OutFile->getBufferStart(), &FatHeader, sizeof(MachO::fat_header));
+
+  for (size_t Index = 0, Size = Slices.size(); Index < Size; ++Index) {
+    MemoryBufferRef BufferRef = Slices[Index].ObjectFile->getMemoryBufferRef();
+    std::copy(BufferRef.getBufferStart(), BufferRef.getBufferEnd(),
+              OutFile->getBufferStart() + FatArchList[Index].offset);
+  }
+
+  // FatArchs written after Slices in order reduce the number of swaps for the
+  // LittleEndian case
+  if (sys::IsLittleEndianHost)
+    for (FatArchType &FA : FatArchList)
+      MachO::swapStruct(FA);
+  std::memcpy(OutFile->getBufferStart() + sizeof(MachO::fat_header),
+              FatArchList.begin(), sizeof(FatArchType) * FatArchList.size());
+
+  if (Error E = OutFile->commit())
+    reportError(OutputFileName, std::move(E));
+}
+
+LLVM_ATTRIBUTE_NORETURN
+static void createUniversalBinary(ArrayRef<OwningBinary<Binary>> InputBinaries,
+                                  StringRef OutputFileName, bool Is64Bit) {
+  assert(InputBinaries.size() >= 1 && "Incorrect number of input binaries");
+  assert(!OutputFileName.empty() && "Create expects a single output file");
+
+  SmallVector<std::unique_ptr<MachOObjectFile>, 1> ExtractedObjects;
+  SmallVector<Slice, 1> Slices = buildSlices(InputBinaries, ExtractedObjects);
+  checkArchDuplicates(Slices);
+  if (Is64Bit)
+    createUniversalBinary<MachO::fat_arch_64>(Slices, OutputFileName);
+  else
+    createUniversalBinary<MachO::fat_arch>(Slices, OutputFileName);
+
+  exit(EXIT_SUCCESS);
+}
+
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   Config C = parseLipoOptions(makeArrayRef(argv + 1, argc));
   SmallVector<OwningBinary<Binary>, 1> InputBinaries =
       readInputBinaries(C.InputFiles);
 
   switch (C.ActionToPerform) {
   case LipoAction::VerifyArch:
     verifyArch(InputBinaries, C.VerifyArchList);
     break;
   case LipoAction::PrintArchs:
     printArchs(InputBinaries);
     break;
   case LipoAction::ThinArch:
     extractSlice(InputBinaries, C.ThinArchType, C.OutputFile);
     break;
+  case LipoAction::CreateUniversal:
+    createUniversalBinary(InputBinaries, C.OutputFile, C.Is64Bit);
+    break;
   }
   return EXIT_SUCCESS;
 }