Universal MachO: support LLVM IR objects

[aguinet]

Summary

This adds support for LLVM IR "objects" within universal MachO, as this can happen when using LTO when compiling iOS/tvOS applications (or any universal MachO object compiled with clang).

This also improves llvm-lipo in order to support these LLVM IR objects. llvm-lipo is now able to extract/thin, create and dump information for universal MachO with LLVM IR bitcode objects.

One strategy to test this properly would require implementing LLVM IR description within the ObjectYAML library. Before doing so, I would like to here about other potential strategies!

[alexander-shaposhnikov]

@aguinet,
thanks for the patch!

1. This code has been recently refactored (see https://github.com/llvm/llvm-project/commit/df69492cdfa82ff6453c887cd45b3a5903b79afb ) so you'd need to rebase your diff.
2. Bitcode files can also come from archives (static libraries) (e.g. an archive can contain bitcode files exclusively) - so when we create a Slice from an archive we also need to handle that.
3. We need tests.

Somewhat related to this area - If I'm not mistaken there is a small issue in SymbolicFile::createSymbolicFile - when LLVMContext is null the function appears to return a misleading error - I was planning to fix that soon.

[aguinet]

Hello @alexshap!

Thanks for the comments. Answers below:

In D85740#2210765, @alexshap wrote:

1. This code has been recently refactored (see https://github.com/llvm/llvm-project/commit/df69492cdfa82ff6453c887cd45b3a5903b79afb ) so you'd need to rebase your diff.

I pushed a new patch rebased on master, sorry about this conflict (did this patch before going to holidays, should have rebased before submitting when coming back :)).

1. Bitcode files can also come from archives (static libraries) (e.g. an archive can contain bitcode files exclusively) - so when we create a Slice from an archive we also need to handle that.

That's a good catch. I will take a closer look and adapt the patch accordingly.

1. We need tests.

About that part, like I said in the description, the way I see it is to enhance the ObjectYAML library so that we can generate LLVM bitcode file format (as described in https://llvm.org/docs/BitCodeFormat.html), so that yaml2obj can generate appropriate LLVM IR test objects. That would be used for instance to test the -create flag. Do you see another way to do this?

Somewhat related to this area - If I'm not mistaken there is a small issue in SymbolicFile::createSymbolicFile - when LLVMContext is null the function appears to return a misleading error - I was planning to fix that soon.

Indeed. If LLVMCOntext is null, it says that it is in an invalid format. Not ideal what should be the error, as this is an error which is forwarded to the end user (and I'm not sure the user would understand "you need to pass an LLVMContext object to SymbolicFile::createSymbolicFile to parse IR objects" :))

[smeenai]

About that part, like I said in the description, the way I see it is to enhance the ObjectYAML library so that we can generate LLVM bitcode file format (as described in https://llvm.org/docs/BitCodeFormat.html), so that yaml2obj can generate appropriate LLVM IR test objects. That would be used for instance to test the -create flag. Do you see another way to do this?

Can't you just use llvm-as to produce bitcode files and feed those to llvm-lipo?

[aguinet]

In D85740#2214477, @smeenai wrote:

About that part, like I said in the description, the way I see it is to enhance the ObjectYAML library so that we can generate LLVM bitcode file format (as described in https://llvm.org/docs/BitCodeFormat.html), so that yaml2obj can generate appropriate LLVM IR test objects. That would be used for instance to test the -create flag. Do you see another way to do this?

Can't you just use llvm-as to produce bitcode files and feed those to llvm-lipo?

Indeed, I can, that's easier... I will try and do that properly next week. Thanks for the hint!

[alexander-shaposhnikov]

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

31

nit: these includes need to be moved up (if i remember correctly we usually try to sort includes alphabetically)

[aguinet]

Hello @alexshap,

Here is a new patch that includes:

• support for archives that includes LLVM IR objects
• testing using llvm-ar
• fix the order of includes in llvm-lipo (as per your comment)

It also includes a few refactoring of code.

I don't know how much we need to be consistent on the original lipo regarding the error message, but I tried to follow the existing convention.

[aguinet]

Fix fatal error message of MachOUniversalBinary::ObjectForArch::getAsIRObject

[aguinet]

Clang-tidy + format remarks

[aguinet]

Cleanup/refactoring

[alexander-shaposhnikov]

llvm/lib/Object/MachOUniversalWriter.cpp

140

perhaps, given the check above this assert is not super useful
if you decide to keep it then we need to add a string message

assert (.... && "....")

149

nit:

1. auto -> explicit type (since it's not clear from the right-hand side),
2. for a single-line "if" braces are not necessary.

(and the same applies to lines 216 - 219)

151

not particularly important, but I'd probably convert "if" + "continue" into

if ( ... ) { ... } else if ( ... ) { ... } else { ... }

(it seems to be more readable)

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

129

what would you say to the following renaming:

irSlice -> createSliceFromIR
archiveSlice -> createSliceFromArchive

129

I'm wondering if we really need to pass the name of the file here - can't it be extracted from the first argument (IRO->getFileName()) ?

(if yes - then probably it can be removed from archiveSlice as well)

P.S. https://llvm.org/doxygen/MachOUniversal_8cpp_source.html#l00078

390

nit: explicit type

557

nit: explicit type

575

nit: explicit type

[alexander-shaposhnikov]

llvm/lib/Object/MachOUniversalWriter.cpp

139

nit: explicit type

[aguinet]

Thanks @alexshap for your review and comments! Answers are inline.

I will try and push a new diff with the suggested modifications during the day.

llvm/lib/Object/MachOUniversalWriter.cpp

140

Indeed. I put it during development to make sure I didn't make any mistake, but I will remove it.

149

Ack will fix with new diff

151

Okay will fix with new diff!

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

129

Probably. I will test and let you know :)

No problem for me for the renaming you propose, will put it in the new diff.

[aguinet]

@alexshap there we go, it should fix all your remarks. Please let my know if there are still some issues.

[aguinet]

Just a small variable naming cleanup

[alexander-shaposhnikov]

LGTM

[smeenai]

I think llvm-libtool-darwin would also need some adjustments to handle bitcode objects, archives, and universal binaries. That's definitely out of scope for this diff, but I'm just flagging it as another tool with missing bitcode support.

llvm/include/llvm/Object/MachOUniversalWriter.h

19

Nit: how come you're including the header here instead of forward declaring IRObjectFile?

[alexander-shaposhnikov]

llvm/lib/Object/MachOUniversalWriter.cpp

90

nit: a blank line between 90 and 91 would not hurt

[aguinet]

Fresh air!

[aguinet]

Thanks for the new reviews! Fixed in the incoming diff

llvm/include/llvm/Object/MachOUniversalWriter.h

19

Nice catch! Fixed in the new diff

[aguinet]

@alexshap note that I don't have RW access to the llvm repository, so I can't merge this myself

[aguinet]

This patch fixes one bug that was present: running llvm-lipo -archs on an LLVM IR object would crash, because we didn't check for that case in printBinaryArchs. This new patch fixes it, with an associated test.

[aguinet]

Thanks for the merge and reviews @alexshap (and @smeenai) !

llvm/include/llvm/Object/Binary.h

 template <typename T> T* OwningBinary<T>::getBinary() {
   return Bin.get();
 }
 
 template <typename T> const T* OwningBinary<T>::getBinary() const {
   return Bin.get();
 }
 
-Expected<OwningBinary<Binary>> createBinary(StringRef Path);
+Expected<OwningBinary<Binary>> createBinary(StringRef Path,
+                                            LLVMContext *Context = nullptr);
 
 } // end namespace object
 
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_BINARY_H

llvm/include/llvm/Object/MachOUniversal.h

 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/MachO.h"
 
 namespace llvm {
 class StringRef;
+class Module;
+class LLVMContext;
 
 namespace object {
+class IRObjectFile;
 
 class MachOUniversalBinary : public Binary {
   virtual void anchor();
 
   uint32_t Magic;
   uint32_t NumberOfObjects;
 public:
   static constexpr uint32_t MaxSectionAlignment = 15; /* 2**15 or 0x8000 */
public:
     std::string getArchFlagName() const {
       const char *McpuDefault, *ArchFlag;
       MachOObjectFile::getArchTriple(getCPUType(), getCPUSubType(),
                                      &McpuDefault, &ArchFlag);
       return ArchFlag ? ArchFlag : std::string();
     }
 
     Expected<std::unique_ptr<MachOObjectFile>> getAsObjectFile() const;
+    Expected<std::unique_ptr<IRObjectFile>>
+    getAsIRObject(LLVMContext &Ctx) const;
 
     Expected<std::unique_ptr<Archive>> getAsArchive() const;
   };
 
   class object_iterator {
     ObjectForArch Obj;
   public:
     object_iterator(const ObjectForArch &Obj) : Obj(Obj) {}
public:
   }
 
   Expected<ObjectForArch>
   getObjectForArch(StringRef ArchName) const;
 
   Expected<std::unique_ptr<MachOObjectFile>>
   getMachOObjectForArch(StringRef ArchName) const;
 
+  Expected<std::unique_ptr<IRObjectFile>>
+  getIRObjectForArch(StringRef ArchName, LLVMContext &Ctx) const;
+
   Expected<std::unique_ptr<Archive>>
   getArchiveForArch(StringRef ArchName) const;
 };
 
 }
 }
 
 #endif

llvm/include/llvm/Object/MachOUniversalWriter.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_MACHOUNIVERSALWRITER_H
 #define LLVM_OBJECT_MACHOUNIVERSALWRITER_H
 
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 
 namespace llvm {
 namespace object {
 
 class Slice {
   const Binary *B;
   uint32_t CPUType;
   uint32_t CPUSubType;
   std::string ArchName;
 
   // P2Alignment field stores slice alignment values from universal
   // binaries. This is also needed to order the slices so the total
   // file size can be calculated before creating the output buffer.
   uint32_t P2Alignment;
 
+  Slice(const IRObjectFile *IRO, uint32_t CPUType, uint32_t CPUSubType,
+        std::string ArchName, uint32_t Align);
+
 public:
   explicit Slice(const MachOObjectFile &O);
 
   Slice(const MachOObjectFile &O, uint32_t Align);
 
   static Expected<Slice> create(const Archive *A);
 
+  static Expected<Slice> create(const IRObjectFile *IRO, uint32_t Align) {
+    Triple T(IRO->getTargetTriple());
+
+    auto CPUTypeOrErr = MachO::getCPUType(T);
+    if (!CPUTypeOrErr) {
+      return CPUTypeOrErr.takeError();
+    }
+    const uint32_t CPUType = CPUTypeOrErr.get();
+
+    auto CPUSubTypeOrErr = MachO::getCPUSubType(T);
+    if (!CPUSubTypeOrErr) {
+      return CPUSubTypeOrErr.takeError();
+    }
+    const uint32_t CPUSubType = CPUSubTypeOrErr.get();
+    // We don't directly use the architecture name of the target triple T, as,
+    // for instance, thumb is treated as ARM by the MachOUniversal object.
+    std::string ArchName(
+        MachOObjectFile::getArchTriple(CPUType, CPUSubType).getArchName());
+    return Slice{IRO, CPUType, CPUSubType, std::move(ArchName), Align};
+  }
+
   void setP2Alignment(uint32_t Align) { P2Alignment = Align; }
 
   const Binary *getBinary() const { return B; }
 
   uint32_t getCPUType() const { return CPUType; }
 
   uint32_t getCPUSubType() const { return CPUSubType; }
 

llvm/lib/Object/Binary.cpp

Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
   case file_magic::minidump:
     return MinidumpFile::create(Buffer);
   case file_magic::tapi_file:
     return TapiUniversal::create(Buffer);
   }
   llvm_unreachable("Unexpected Binary File Type");
 }
 
-Expected<OwningBinary<Binary>> object::createBinary(StringRef Path) {
+Expected<OwningBinary<Binary>> object::createBinary(StringRef Path,
+                                                    LLVMContext *Context) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
-      createBinary(Buffer->getMemBufferRef());
+      createBinary(Buffer->getMemBufferRef(), Context);
   if (!BinOrErr)
     return BinOrErr.takeError();
   std::unique_ptr<Binary> &Bin = BinOrErr.get();
 
   return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
 }

llvm/lib/Object/MachOUniversal.cpp

 //===- MachOUniversal.cpp - Mach-O universal binary -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the MachOUniversalBinary class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace object;
if (Parent->getMagic() == MachO::FAT_MAGIC) {
     ObjectData = ParentData.substr(Header64.offset, Header64.size);
     cputype = Header64.cputype;
   }
   StringRef ObjectName = Parent->getFileName();
   MemoryBufferRef ObjBuffer(ObjectData, ObjectName);
   return ObjectFile::createMachOObjectFile(ObjBuffer, cputype, Index);
 }
 
+Expected<std::unique_ptr<IRObjectFile>>
+MachOUniversalBinary::ObjectForArch::getAsIRObject(LLVMContext &Ctx) const {
+  if (!Parent)
+    report_fatal_error("MachOUniversalBinary::ObjectForArch::getAsLLVMModule() "
+                       "called when Parent is a nullptr");
+
+  StringRef ParentData = Parent->getData();
+  StringRef ObjectData;
+  if (Parent->getMagic() == MachO::FAT_MAGIC) {
+    ObjectData = ParentData.substr(Header.offset, Header.size);
+  } else { // Parent->getMagic() == MachO::FAT_MAGIC_64
+    ObjectData = ParentData.substr(Header64.offset, Header64.size);
+  }
+  StringRef ObjectName = Parent->getFileName();
+  MemoryBufferRef ObjBuffer(ObjectData, ObjectName);
+
+  return IRObjectFile::create(ObjBuffer, Ctx);
+}
+
 Expected<std::unique_ptr<Archive>>
 MachOUniversalBinary::ObjectForArch::getAsArchive() const {
   if (!Parent)
     report_fatal_error("MachOUniversalBinary::ObjectForArch::getAsArchive() "
                        "called when Parent is a nullptr");
 
   StringRef ParentData = Parent->getData();
   StringRef ObjectData;

 Expected<std::unique_ptr<MachOObjectFile>>
 MachOUniversalBinary::getMachOObjectForArch(StringRef ArchName) const {
   Expected<ObjectForArch> O = getObjectForArch(ArchName);
   if (!O)
     return O.takeError();
   return O->getAsObjectFile();
 }
 
+Expected<std::unique_ptr<IRObjectFile>>
+MachOUniversalBinary::getIRObjectForArch(StringRef ArchName,
+                                         LLVMContext &Ctx) const {
+  Expected<ObjectForArch> O = getObjectForArch(ArchName);
+  if (!O)
+    return O.takeError();
+  return O->getAsIRObject(Ctx);
+}
+
 Expected<std::unique_ptr<Archive>>
 MachOUniversalBinary::getArchiveForArch(StringRef ArchName) const {
   Expected<ObjectForArch> O = getObjectForArch(ArchName);
   if (!O)
     return O.takeError();
   return O->getAsArchive();
 }

llvm/lib/Object/MachOUniversalWriter.cpp

 }
 
 Slice::Slice(const MachOObjectFile &O, uint32_t Align)
     : B(&O), CPUType(O.getHeader().cputype),
       CPUSubType(O.getHeader().cpusubtype),
       ArchName(std::string(O.getArchTriple().getArchName())),
       P2Alignment(Align) {}
 
+Slice::Slice(const IRObjectFile *IRO, uint32_t CPUType, uint32_t CPUSubType,
+             std::string ArchName, uint32_t Align)
+    : B(IRO), CPUType(CPUType), CPUSubType(CPUSubType),
+      ArchName(std::move(ArchName)), P2Alignment(Align) {}
+
 Slice::Slice(const MachOObjectFile &O) : Slice(O, calculateAlignment(O)) {}
 
 Expected<Slice> Slice::create(const Archive *A) {
   Error Err = Error::success();
   std::unique_ptr<MachOObjectFile> FO = nullptr;
   for (const Archive::Child &Child : A->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
     if (!ChildOrErr)
       return createFileError(A->getFileName(), ChildOrErr.takeError());
     Binary *Bin = ChildOrErr.get().get();
     if (Bin->isMachOUniversalBinary())
       return createStringError(std::errc::invalid_argument,
if (Err)
     return createFileError(A->getFileName(), std::move(Err));
   if (!FO)
     return createStringError(
         std::errc::invalid_argument,
         ("empty archive with no architecture specification: " +
          A->getFileName() + " (can't determine architecture for it)")
             .str()
             .c_str());
 
   Slice ArchiveSlice = Slice(*(FO.get()), FO->is64Bit() ? 3 : 2);
   ArchiveSlice.B = A;
   return ArchiveSlice;
 }
 
 static Expected<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 (const auto &S : Slices) {
     Offset = alignTo(Offset, 1ull << S.getP2Alignment());
     if (Offset > UINT32_MAX)
       return createStringError(
           std::errc::invalid_argument,
           ("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 " + S.getBinary()->getFileName() +
            " for architecture " + S.getArchString() + "exceeds that.")

llvm/tools/llvm-lipo/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Object
   Option
   Support
   TextAPI
+  Core
+  BinaryFormat
 )
 
 set(LLVM_TARGET_DEFINITIONS LipoOpts.td)
 tablegen(LLVM LipoOpts.inc -gen-opt-parser-defs)
 add_public_tablegen_target(LipoOptsTableGen)
 
 add_llvm_tool(llvm-lipo
   llvm-lipo.cpp
   DEPENDS
   LipoOptsTableGen
 )
 
 if(LLVM_INSTALL_CCTOOLS_SYMLINKS)
   add_llvm_tool_symlink(lipo llvm-lipo)
 endif()

llvm/tools/llvm-lipo/LLVMBuild.txt

 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 [component_0]
 type = Tool
 name = llvm-lipo
 parent = Tools
-required_libraries = Object Option Support
+required_libraries = Object Option Support BinaryFormat

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

 //===-- llvm-lipo.cpp - a tool for manipulating universal binaries --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // A utility for creating / splitting / inspecting universal binaries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/MachOUniversalWriter.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/TextAPI/MachO/Architecture.h"
 
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+
 using namespace llvm;
 using namespace llvm::object;
 
 static const StringRef ToolName = "llvm-lipo";
+static LLVMContext LLVMCtx;
 
 LLVM_ATTRIBUTE_NORETURN static void reportError(Twine Message) {
   WithColor::error(errs(), ToolName) << Message << "\n";
   errs().flush();
   exit(EXIT_FAILURE);
 }
 
 LLVM_ATTRIBUTE_NORETURN static void reportError(Error E) {

 
 static Slice archiveSlice(const Archive *A, StringRef File) {
   Expected<Slice> ArchiveOrSlice = Slice::create(A);
   if (!ArchiveOrSlice)
     reportError(File, ArchiveOrSlice.takeError());
   return *ArchiveOrSlice;
 }
 
 } // end namespace
 
 static void validateArchitectureName(StringRef ArchitectureName) {
   if (!MachOObjectFile::isValidArch(ArchitectureName)) {
     std::string Buf;
     raw_string_ostream OS(Buf);
     OS << "Invalid architecture: " << ArchitectureName
        << "\nValid architecture names are:";
     for (auto arch : MachOObjectFile::getValidArchs())
default:
     reportError("llvm-lipo action unspecified");
   }
 }
 
 static SmallVector<OwningBinary<Binary>, 1>
 readInputBinaries(ArrayRef<InputFile> InputFiles) {
   SmallVector<OwningBinary<Binary>, 1> InputBinaries;
   for (const InputFile &IF : InputFiles) {
-    Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(IF.FileName);
+    Expected<OwningBinary<Binary>> BinaryOrErr =
+        createBinary(IF.FileName, &LLVMCtx);
     if (!BinaryOrErr)
       reportError(IF.FileName, BinaryOrErr.takeError());
     const Binary *B = BinaryOrErr->getBinary();
-    if (!B->isArchive() && !B->isMachO() && !B->isMachOUniversalBinary())
+    if (!B->isArchive() && !B->isMachO() && !B->isMachOUniversalBinary() &&
+        !B->isIR())
       reportError("File " + IF.FileName + " has unsupported binary format");
     if (IF.ArchType && (B->isMachO() || B->isArchive())) {
       const auto S = B->isMachO() ? Slice(*cast<MachOObjectFile>(B))
                                   : archiveSlice(cast<Archive>(B), IF.FileName);
       const auto SpecifiedCPUType = MachO::getCPUTypeFromArchitecture(
                                         MachO::getArchitectureFromName(
                                             Triple(*IF.ArchType).getArchName()))
                                         .first;
static void verifyArch(ArrayRef<OwningBinary<Binary>> InputBinaries,
   }
   exit(EXIT_SUCCESS);
 }
 
 static void printBinaryArchs(const Binary *Binary, raw_ostream &OS) {
   // Prints trailing space for compatibility with cctools lipo.
   if (auto UO = dyn_cast<MachOUniversalBinary>(Binary)) {
     for (const auto &O : UO->objects()) {
+      // Order here is important, because both MachOObjectFile and
+      // IRObjectFile can be created with a binary that has embedded bitcode.
       Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrError =
           O.getAsObjectFile();
       if (MachOObjOrError) {
         OS << Slice(*(MachOObjOrError->get())).getArchString() << " ";
         continue;
       }
+      Expected<std::unique_ptr<IRObjectFile>> IROrError =
+          O.getAsIRObject(LLVMCtx);
+      if (IROrError) {
+        consumeError(MachOObjOrError.takeError());
+        auto SliceOrErr = Slice::create(IROrError->get(), O.getAlign());
+        if (!SliceOrErr) {
+          reportError(Binary->getFileName(), SliceOrErr.takeError());
+          continue;
+        }
+        OS << SliceOrErr.get().getArchString() << " ";
+        continue;
+      }
       Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive();
       if (ArchiveOrError) {
         consumeError(MachOObjOrError.takeError());
+        consumeError(IROrError.takeError());
         OS << archiveSlice(ArchiveOrError->get(), Binary->getFileName())
                   .getArchString()
            << " ";
         continue;
       }
       consumeError(ArchiveOrError.takeError());
       reportError(Binary->getFileName(), MachOObjOrError.takeError());
+      reportError(Binary->getFileName(), IROrError.takeError());
     }
     OS << "\n";
     return;
   }
   OS << Slice(*cast<MachOObjectFile>(Binary)).getArchString() << " \n";
 }
 
 LLVM_ATTRIBUTE_NORETURN
reportError("input file " +
                 InputBinaries.front().getBinary()->getFileName() +
                 " must be a fat file when the -thin option is specified");
     exit(EXIT_FAILURE);
   }
 
   auto *UO = cast<MachOUniversalBinary>(InputBinaries.front().getBinary());
   Expected<std::unique_ptr<MachOObjectFile>> Obj =
       UO->getMachOObjectForArch(ArchType);
+  Expected<std::unique_ptr<IRObjectFile>> IRObj =
+      UO->getIRObjectForArch(ArchType, LLVMCtx);
   Expected<std::unique_ptr<Archive>> Ar = UO->getArchiveForArch(ArchType);
-  if (!Obj && !Ar)
+  if (!Obj && !IRObj && !Ar)
     reportError("fat input file " + UO->getFileName() +
                 " does not contain the specified architecture " + ArchType +
                 " to thin it to");
-  Binary *B = Obj ? static_cast<Binary *>(Obj->get())
-                  : static_cast<Binary *>(Ar->get());
+  Binary *B;
+  // Order here is important, because both Obj and IRObj will be valid with a
+  // binary that has embedded bitcode.
+  if (Obj)
+    B = Obj->get();
+  else if (IRObj)
+    B = IRObj->get();
+  else
+    B = Ar->get();
+
   Expected<std::unique_ptr<FileOutputBuffer>> OutFileOrError =
       FileOutputBuffer::create(OutputFileName,
                                B->getMemoryBufferRef().getBufferSize(),
                                sys::fs::can_execute(UO->getFileName())
                                    ? FileOutputBuffer::F_executable
                                    : 0);
   if (!OutFileOrError)
     reportError(OutputFileName, OutFileOrError.takeError());
for (StringRef Arch : Alignments.keys())
     if (!HasArch(Arch))
       reportError("-segalign " + Arch +
                   " <value> specified but resulting fat file does not contain "
                   "that architecture ");
 }
 
 // Updates vector ExtractedObjects with the MachOObjectFiles extracted from
 // Universal Binary files to transfer ownership.
-static SmallVector<Slice, 2> buildSlices(
-    ArrayRef<OwningBinary<Binary>> InputBinaries,
+static SmallVector<Slice, 2>
+buildSlices(ArrayRef<OwningBinary<Binary>> InputBinaries,
             const StringMap<const uint32_t> &Alignments,
-    SmallVectorImpl<std::unique_ptr<MachOObjectFile>> &ExtractedObjects) {
+            SmallVectorImpl<std::unique_ptr<SymbolicFile>> &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()) {
+        // Order here is important, because both MachOObjectFile and
+        // IRObjectFile can be created with a binary that has embedded bitcode.
         Expected<std::unique_ptr<MachOObjectFile>> BinaryOrError =
             O.getAsObjectFile();
-        if (!BinaryOrError)
-          reportError(InputBinary->getFileName(), BinaryOrError.takeError());
+        if (BinaryOrError) {
+          Slices.emplace_back(*(BinaryOrError.get()), O.getAlign());
           ExtractedObjects.push_back(std::move(BinaryOrError.get()));
-        Slices.emplace_back(*(ExtractedObjects.back().get()), O.getAlign());
+          continue;
+        }
+        Expected<std::unique_ptr<IRObjectFile>> IROrError =
+            O.getAsIRObject(LLVMCtx);
+        if (IROrError) {
+          consumeError(BinaryOrError.takeError());
+          auto SliceOrErr = Slice::create(
+              static_cast<IRObjectFile *>(IROrError.get().get()), O.getAlign());
+          if (!SliceOrErr) {
+            reportError(InputBinary->getFileName(), SliceOrErr.takeError());
+            continue;
+          }
+          ExtractedObjects.emplace_back(std::move(IROrError.get()));
+          Slices.emplace_back(std::move(SliceOrErr.get()));
+          continue;
+        }
+        reportError(InputBinary->getFileName(), BinaryOrError.takeError());
       }
     } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
       Slices.emplace_back(*O);
     } else if (auto A = dyn_cast<Archive>(InputBinary)) {
       Slices.push_back(archiveSlice(A, InputBinary->getFileName()));
+    } else if (auto IRO = dyn_cast<IRObjectFile>(InputBinary)) {
+      // Original Apple's lipo set the alignment to 0
+      auto SliceOrErr = Slice::create(IRO, 0);
+      if (!SliceOrErr) {
+        reportError(InputBinary->getFileName(), SliceOrErr.takeError());
+        continue;
+      }
+      Slices.emplace_back(std::move(SliceOrErr.get()));
     } else {
       llvm_unreachable("Unexpected binary format");
     }
   }
   updateAlignments(Slices, Alignments);
   return Slices;
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void createUniversalBinary(ArrayRef<OwningBinary<Binary>> InputBinaries,
                                   const StringMap<const uint32_t> &Alignments,
                                   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<std::unique_ptr<SymbolicFile>, 1> ExtractedObjects;
   SmallVector<Slice, 1> Slices =
       buildSlices(InputBinaries, Alignments, ExtractedObjects);
   checkArchDuplicates(Slices);
   checkUnusedAlignments(Slices, Alignments);
 
   llvm::stable_sort(Slices);
   if (Error E = writeUniversalBinary(Slices, OutputFileName))
     reportError(std::move(E));
static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
   assert(!OutputFileName.empty() && "Thin expects a single output file");
 
   if (InputBinaries.front().getBinary()->isMachO()) {
     reportError("input file " +
                 InputBinaries.front().getBinary()->getFileName() +
                 " must be a fat file when the -extract option is specified");
   }
 
-  SmallVector<std::unique_ptr<MachOObjectFile>, 2> ExtractedObjects;
+  SmallVector<std::unique_ptr<SymbolicFile>, 2> ExtractedObjects;
   SmallVector<Slice, 2> Slices =
       buildSlices(InputBinaries, Alignments, ExtractedObjects);
   erase_if(Slices, [ArchType](const Slice &S) {
     return ArchType != S.getArchString();
   });
 
   if (Slices.empty())
     reportError(
reportError("input file " +
                 InputBinaries.front().getBinary()->getFileName() +
                 " must be a fat file when the -replace option is specified");
 
   SmallVector<OwningBinary<Binary>, 1> ReplacementBinaries =
       readInputBinaries(ReplacementFiles);
 
   StringMap<Slice> ReplacementSlices =
       buildReplacementSlices(ReplacementBinaries, Alignments);
-  SmallVector<std::unique_ptr<MachOObjectFile>, 2> ExtractedObjects;
+  SmallVector<std::unique_ptr<SymbolicFile>, 2> ExtractedObjects;
   SmallVector<Slice, 2> Slices =
       buildSlices(InputBinaries, Alignments, ExtractedObjects);
 
   for (auto &Slice : Slices) {
     auto It = ReplacementSlices.find(Slice.getArchString());
     if (It != ReplacementSlices.end()) {
       Slice = It->second;
       ReplacementSlices.erase(It); // only keep remaining replacing arch_types