[llvm-lipo] Implement -info

[anushabasana]

Summary

Prints architecture type of all input files.

Test Plan: check-llvm

[anushabasana]

Fix diff

[compnerd]

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

269–270

OS is the naming convention for the output stream

286–323

I think it may be nicer to change L280-L286 to something like:

    OS << '\n';
    return;
  }

  auto *O = cast<MachOObjectFile>(Binary);
  OS << getArchString(*O) << " \n";
}

318

Similar to above, you can use continue in the universal case and unindent the else case (make the Binary->isMachO() an assertion, and drop the unreachable.

547

Is there validation being applied here? I think that you should add a test case for invalid input as well (that is, pass ELF files to lipo and ensure that we handle that gracefully (right now, it feels like we may just abort?).

[alexander-shaposhnikov]

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

547

if I'm not mistaken readInputBinaries takes care of it, otherwise this would be reimplemented N times where N is the number of supported actions. Having an extra test of -info would not hurt though.

[alexander-shaposhnikov]

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

269–270

+1

301

khm, the same effect (grouping universal/regular files) could be achieved a bit simpler, what would you say to the following (no need for std::string, raw_string_ostream, ThinOutputBuffer, ThinOutputStream, UniversalOutputBuffer, UniversalOutputStream, etc)

 
for (const auto &IB : InputBinaries)
    if (IB.getBinary()->isMachOUniversalBinary()) {
         outs() << "Architectures in the fat file: " << Binary->getFileName() 
                   << " are: ";
         printBinaryArchs(IB.getBinary(), outs());
    }
 for (const auto &IB : InputBinaries)
    if (IB.getBinary()->isMachO) {
         outs() << "Non-fat file: " << IB.getBinary()->getFileName()
                   << " is architecture: ";
         printBinaryArchs(IB.getBinary(), outs());
    }

[alexander-shaposhnikov]

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

301

cc: @mtrent

1. The wording (especially in the second case) appears to be very weird, maybe it's worth to change it and make it more human-readable ? (I suspect -info is not really widely used in scripts, so probably this incompatibility might not be a big issue).
2. Maybe we don't even need to group anything here (for the same reasons)

[anushabasana]

Address review comments

[anushabasana]

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

301

I could remove the string and OS for Universal files and just pass in outs() to cut down there.
I originally had 2 for loops but I thought the multiple OS would be better so we would only have to do one pass over the input binaries.
I'm not sure what is more legible, I don't have a strong preference.

[compnerd]

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

301

@alexshap - I think that I would rather that we go with stronger claims:

for (const auto &IB : InputBinaries) {
  Binary *B = IB.getBinary();
  assert(B->isMachO() && "expected MachO binary");
  outs() << "Non-fat file: " << B->getFileName() << " is architecture: ";
  printBinaryArchs(B, outs());
}

547

Ah, okay, I was trying to see where that was called, I guess I just failed to see it. Yes, a test would be good still.

[alexander-shaposhnikov]

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

301

I don't think that performance is really a concern here (and in any case IO + allocations are more expensive than two "for" loops are), so I'd prefer to make this code as simple as possible,
in particular, get rid of these intermediate strings and buffers (I'm referring to ThinOutputBuffer, ThinOS, etc)

[compnerd]

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

301

It seemed that this was confusing for @alexshap, what I meant is that this could be written as:

for (const auto &IB : InputBinaries) {
  if (IB.getBinary()->isMachOUniversalBinary()) {
    ...
  }
}
for (const auto &IB : InputBinaries) {
  if (!IB.getBinary()->isMachOUniversalBinary()) {
    ...
  }
}

which makes it more explicit that the two loops explicitly go over everything just filtering on a specific condition.

[anushabasana]

Removed extra OS

[anushabasana]

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

547

I added test info-invalid.test

[smeenai]

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

301

I've definitely seen -info be used in some scripts, particularly since -archs is a more recent invention, I think. I think it's best if we match lipo output here.

[alexander-shaposhnikov]

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

301

ok, then let's leave it as is

[alexander-shaposhnikov]

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

285

OS << getArchString(*cast<MachOObjectFile>(Binary))

[alexander-shaposhnikov]

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

364–532

in order to ...

[anushabasana]

Address review comments

[alexander-shaposhnikov]

LG

[alexander-shaposhnikov]

llvm/test/tools/llvm-lipo/info.test

8

CHECK
CHECK-NEXT
CHECK-NEXT
...

(to verify that the order is correct)

[anushabasana]

Test file uses CHECK-NEXT instead of CHECK

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-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/info.test

+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-i386.o
+# RUN: yaml2obj %p/Inputs/x86_64-slice.yaml > %t-x86_64.o
+# RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml > %t-universal.o
+
+# RUN: llvm-lipo %t-universal.o %t-i386.o %t-universal.o %t-x86_64.o -info | FileCheck %s
+# CHECK: Architectures in the fat file:
+# CHECK: i386 x86_64
+# CHECK: Architectures in the fat file:
+# CHECK: i386 x86_64
+# CHECK: Non-fat file:
+# CHECK:  is architecture: i386
+# CHECK: Non-fat file:
+# CHECK:  is architecture: x86_64

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

: 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 info : Option<["-", "--"], "info", KIND_FLAG>,
+           Group<action_group>,
+           HelpText<"Display descriptions of each input file including "
+                    "filename and arch_types. Groups universal binaries "
+                    "together followed by thin files">;
+
 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

 
 class LipoOptTable : public opt::OptTable {
 public:
   LipoOptTable() : OptTable(LipoInfoTable) {}
 };
 
 enum class LipoAction {
   PrintArchs,
+  PrintInfo,
   VerifyArch,
   ThinArch,
+  CreateUniversal,
 };
 
 struct Config {
   SmallVector<std::string, 1> InputFiles;
   SmallVector<std::string, 1> VerifyArchList;
   std::string ThinArchType;
   std::string OutputFile;
   LipoAction ActionToPerform;
 };
 
+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) {
case LIPO_verify_arch:
     return C;
 
   case LIPO_archs:
     if (C.InputFiles.size() > 1)
       reportError("archs expects a single input file");
     C.ActionToPerform = LipoAction::PrintArchs;
     return C;
 
+  case LIPO_info:
+    C.ActionToPerform = LipoAction::PrintInfo;
+    return C;
+
   case LIPO_thin:
     if (C.InputFiles.size() > 1)
       reportError("thin expects a single input file");
     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) {
+  const 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();
+}
+
+static void printBinaryArchs(const Binary *Binary, raw_ostream &OutputStream) {
+  // Prints trailing space for compatibility with cctools lipo.
+  if (auto UO = dyn_cast<MachOUniversalBinary>(Binary)) {
+    for (const auto &O : UO->objects()) {
+      Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
+          O.getAsObjectFile();
+      if (!BinaryOrError)
+        reportError(Binary->getFileName(), BinaryOrError.takeError());
+      OutputStream << getArchString(*BinaryOrError.get().get()) << " ";
+    }
+  } else if (auto O = dyn_cast<MachOObjectFile>(Binary)) {
+    OutputStream << getArchString(*O) << " ";
+  } else {
+    llvm_unreachable("Unexpected binary format");
+  }
+
+  OutputStream << "\n";
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void printArchs(ArrayRef<OwningBinary<Binary>> InputBinaries) {
   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) {
-      Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
-          I->getAsObjectFile();
-      if (!BinaryOrError)
-        reportError(InputBinary->getFileName(), BinaryOrError.takeError());
-      printArchOrUnknown(BinaryOrError.get().get());
-    }
-  } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
-    printArchOrUnknown(O);
+  std::string OutputBuffer;
+  raw_string_ostream OutputStream(OutputBuffer);
+  printBinaryArchs(InputBinaries.front().getBinary(), OutputStream);
+  outs() << OutputStream.str();
+  exit(EXIT_SUCCESS);
+
+LLVM_ATTRIBUTE_NORETURN
+static void printInfo(ArrayRef<OwningBinary<Binary>> InputBinaries) {
+  std::string UniversalOutputBuffer;
+  raw_string_ostream UniversalOutputStream(UniversalOutputBuffer);
+  std::string ThinOutputBuffer;
+  raw_string_ostream ThinOutputStream(ThinOutputBuffer);
+  for (auto &IB : InputBinaries) {
+    const Binary *Binary = IB.getBinary();
+    if (Binary->isMachOUniversalBinary()) {
+      UniversalOutputStream
+          << "Architectures in the fat file: " << Binary->getFileName()
+          << " are: ";
+      printBinaryArchs(Binary, UniversalOutputStream);
+    } else if (Binary->isMachO()) {
+      ThinOutputStream << "Non-fat file: " << Binary->getFileName()
+                       << " is architecture: ";
+      printBinaryArchs(Binary, ThinOutputStream);
     } else {
       llvm_unreachable("Unexpected binary format");
     }
+  }
+  // Group universal and thin files together for compatibility with cctools lipo
+  outs() << UniversalOutputStream.str();
+  outs() << ThinOutputStream.str();
 
-  outs() << "\n";
   exit(EXIT_SUCCESS);
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
                          StringRef ThinArchType, StringRef OutputFileName) {
   assert(!ThinArchType.empty() && "The architecture type should be non-empty");
   assert(InputBinaries.size() == 1 && "Incorrect number of input binaries");
if (!OutFileOrError)
     reportError(OutputFileName, OutFileOrError.takeError());
   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;
+  auto CPUIDForSlice = [](const Slice &S) {
+    return static_cast<uint64_t>(S.ObjectFile->getHeader().cputype) << 32 |
+           S.ObjectFile->getHeader().cpusubtype;
+  };
+  for (const auto &S : Slices) {
+    auto Entry = CPUIds.try_emplace(CPUIDForSlice(S), 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.
+
+  switch (ObjectFile->getHeader().cputype) {
+  case MachO::CPU_TYPE_I386:
+  case MachO::CPU_TYPE_X86_64:
+  case MachO::CPU_TYPE_POWERPC:
+  case MachO::CPU_TYPE_POWERPC64:
+    return 12; // log2 value of page size(4k) for x86 and PPC
+  case MachO::CPU_TYPE_ARM:
+  case MachO::CPU_TYPE_ARM64:
+  case MachO::CPU_TYPE_ARM64_32:
+    return 14; // log2 value of page size(16k) for Darwin ARM
+  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 &O : UO->objects()) {
+        Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
+            O.getAsObjectFile();
+        if (!BinaryOrError)
+          reportError(InputBinary->getFileName(), BinaryOrError.takeError());
+        ExtractedObjects.push_back(std::move(BinaryOrError.get()));
+        Slices.push_back(Slice{ExtractedObjects.back().get(), O.getAlign()});
+      }
+    } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
+      Slices.push_back(Slice{O, calculateAlignment(O)});
+    } else {
+      llvm_unreachable("Unexpected binary format");
+    }
+  }
+  return Slices;
+}
+
+static SmallVector<MachO::fat_arch, 2>
+buildFatArchList(ArrayRef<Slice> Slices) {
+  SmallVector<MachO::fat_arch, 2> FatArchList;
+  uint64_t Offset =
+      sizeof(MachO::fat_header) + Slices.size() * sizeof(MachO::fat_arch);
+
+  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 (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.");
+
+    MachO::fat_arch 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;
+}
+
+static void createUniversalBinary(SmallVectorImpl<Slice> &Slices,
+                                  StringRef OutputFileName) {
+  MachO::fat_header FatHeader;
+  FatHeader.magic = MachO::FAT_MAGIC;
+  FatHeader.nfat_arch = Slices.size();
+
+  stable_sort(Slices, compareSlices);
+  SmallVector<MachO::fat_arch, 2> FatArchList = buildFatArchList(Slices);
+
+  const bool IsExecutable = any_of(Slices, [](Slice S) {
+    return sys::fs::can_execute(S.ObjectFile->getFileName());
+  });
+  const 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 (MachO::fat_arch &FA : FatArchList)
+      MachO::swapStruct(FA);
+  std::memcpy(OutFile->getBufferStart() + sizeof(MachO::fat_header),
+              FatArchList.begin(),
+              sizeof(MachO::fat_arch) * FatArchList.size());
+
+  if (Error E = OutFile->commit())
+    reportError(OutputFileName, std::move(E));
+}
+
+LLVM_ATTRIBUTE_NORETURN
+static void createUniversalBinary(ArrayRef<OwningBinary<Binary>> InputBinaries,
+                                  StringRef OutputFileName) {
+  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);
+  createUniversalBinary(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::PrintInfo:
+    printInfo(InputBinaries);
+    break;
   case LipoAction::ThinArch:
     extractSlice(InputBinaries, C.ThinArchType, C.OutputFile);
     break;
+  case LipoAction::CreateUniversal:
+    createUniversalBinary(InputBinaries, C.OutputFile);
+    break;
   }
   return EXIT_SUCCESS;
 }