diff --git a/llvm/include/llvm/Object/MachOUniversalWriter.h b/llvm/include/llvm/Object/MachOUniversalWriter.h
--- a/llvm/include/llvm/Object/MachOUniversalWriter.h
+++ b/llvm/include/llvm/Object/MachOUniversalWriter.h
@@ -35,7 +35,7 @@
   // file size can be calculated before creating the output buffer.
   uint32_t P2Alignment;
 
-  Slice(const IRObjectFile *IRO, uint32_t CPUType, uint32_t CPUSubType,
+  Slice(const IRObjectFile &IRO, uint32_t CPUType, uint32_t CPUSubType,
         std::string ArchName, uint32_t Align);
 
 public:
@@ -43,10 +43,10 @@
 
   Slice(const MachOObjectFile &O, uint32_t Align);
 
-  static Expected<Slice> create(const Archive *A,
+  static Expected<Slice> create(const Archive &A,
                                 LLVMContext *LLVMCtx = nullptr);
 
-  static Expected<Slice> create(const IRObjectFile *IRO, uint32_t Align);
+  static Expected<Slice> create(const IRObjectFile &IRO, uint32_t Align);
 
   void setP2Alignment(uint32_t Align) { P2Alignment = Align; }
 
diff --git a/llvm/lib/Object/MachOUniversalWriter.cpp b/llvm/lib/Object/MachOUniversalWriter.cpp
--- a/llvm/lib/Object/MachOUniversalWriter.cpp
+++ b/llvm/lib/Object/MachOUniversalWriter.cpp
@@ -81,9 +81,9 @@
       ArchName(std::string(O.getArchTriple().getArchName())),
       P2Alignment(Align) {}
 
-Slice::Slice(const IRObjectFile *IRO, uint32_t CPUType, uint32_t CPUSubType,
+Slice::Slice(const IRObjectFile &IRO, uint32_t CPUType, uint32_t CPUSubType,
              std::string ArchName, uint32_t Align)
-    : B(IRO), CPUType(CPUType), CPUSubType(CPUSubType),
+    : B(&IRO), CPUType(CPUType), CPUSubType(CPUSubType),
       ArchName(std::move(ArchName)), P2Alignment(Align) {}
 
 Slice::Slice(const MachOObjectFile &O) : Slice(O, calculateAlignment(O)) {}
@@ -105,14 +105,14 @@
   return getMachoCPUFromTriple(Triple{TT});
 }
 
-Expected<Slice> Slice::create(const Archive *A, LLVMContext *LLVMCtx) {
+Expected<Slice> Slice::create(const Archive &A, LLVMContext *LLVMCtx) {
   Error Err = Error::success();
   std::unique_ptr<MachOObjectFile> MFO = nullptr;
   std::unique_ptr<IRObjectFile> IRFO = nullptr;
-  for (const Archive::Child &Child : A->children(Err)) {
+  for (const Archive::Child &Child : A.children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(LLVMCtx);
     if (!ChildOrErr)
-      return createFileError(A->getFileName(), ChildOrErr.takeError());
+      return createFileError(A.getFileName(), ChildOrErr.takeError());
     Binary *Bin = ChildOrErr.get().get();
     if (Bin->isMachOUniversalBinary())
       return createStringError(std::errc::invalid_argument,
@@ -191,32 +191,32 @@
                                    .c_str());
   }
   if (Err)
-    return createFileError(A->getFileName(), std::move(Err));
+    return createFileError(A.getFileName(), std::move(Err));
   if (!MFO && !IRFO)
     return createStringError(
         std::errc::invalid_argument,
         ("empty archive with no architecture specification: " +
-         A->getFileName() + " (can't determine architecture for it)")
+         A.getFileName() + " (can't determine architecture for it)")
             .str()
             .c_str());
 
   if (MFO) {
     Slice ArchiveSlice(*(MFO.get()), MFO->is64Bit() ? 3 : 2);
-    ArchiveSlice.B = A;
+    ArchiveSlice.B = &A;
     return ArchiveSlice;
   }
 
   // For IR objects
-  Expected<Slice> ArchiveSliceOrErr = Slice::create(IRFO.get(), 0);
+  Expected<Slice> ArchiveSliceOrErr = Slice::create(*IRFO, 0);
   if (!ArchiveSliceOrErr)
-    return createFileError(A->getFileName(), ArchiveSliceOrErr.takeError());
+    return createFileError(A.getFileName(), ArchiveSliceOrErr.takeError());
   auto &ArchiveSlice = ArchiveSliceOrErr.get();
-  ArchiveSlice.B = A;
-  return Slice{std::move(ArchiveSlice)};
+  ArchiveSlice.B = &A;
+  return std::move(ArchiveSlice);
 }
 
-Expected<Slice> Slice::create(const IRObjectFile *IRO, uint32_t Align) {
-  Expected<MachoCPUTy> CPUOrErr = getMachoCPUFromTriple(IRO->getTargetTriple());
+Expected<Slice> Slice::create(const IRObjectFile &IRO, uint32_t Align) {
+  Expected<MachoCPUTy> CPUOrErr = getMachoCPUFromTriple(IRO.getTargetTriple());
   if (!CPUOrErr)
     return CPUOrErr.takeError();
   unsigned CPUType, CPUSubType;
diff --git a/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp b/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp
--- a/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp
+++ b/llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp
@@ -377,7 +377,7 @@
   SmallVector<Slice, 2> Slices;
 
   for (const auto &OB : OutputBinaries) {
-    const Archive *A = OB.getBinary();
+    const Archive &A = *OB.getBinary();
     Expected<Slice> ArchiveSlice = Slice::create(A);
     if (!ArchiveSlice)
       return ArchiveSlice.takeError();
diff --git a/llvm/tools/llvm-lipo/llvm-lipo.cpp b/llvm/tools/llvm-lipo/llvm-lipo.cpp
--- a/llvm/tools/llvm-lipo/llvm-lipo.cpp
+++ b/llvm/tools/llvm-lipo/llvm-lipo.cpp
@@ -118,17 +118,17 @@
   LipoAction ActionToPerform;
 };
 
-static Slice createSliceFromArchive(const Archive *A) {
+static Slice createSliceFromArchive(const Archive &A) {
   Expected<Slice> ArchiveOrSlice = Slice::create(A, &LLVMCtx);
   if (!ArchiveOrSlice)
-    reportError(A->getFileName(), ArchiveOrSlice.takeError());
+    reportError(A.getFileName(), ArchiveOrSlice.takeError());
   return *ArchiveOrSlice;
 }
 
-static Slice createSliceFromIR(const IRObjectFile *IRO, unsigned Align) {
+static Slice createSliceFromIR(const IRObjectFile &IRO, unsigned Align) {
   Expected<Slice> IROrErr = Slice::create(IRO, Align);
   if (!IROrErr)
-    reportError(IRO->getFileName(), IROrErr.takeError());
+    reportError(IRO.getFileName(), IROrErr.takeError());
   return *IROrErr;
 }
 
@@ -331,8 +331,8 @@
       const auto S = B->isMachO()
                          ? Slice(*cast<MachOObjectFile>(B))
                          : B->isArchive()
-                               ? createSliceFromArchive(cast<Archive>(B))
-                               : createSliceFromIR(cast<IRObjectFile>(B), 0);
+                               ? createSliceFromArchive(*cast<Archive>(B))
+                               : createSliceFromIR(*cast<IRObjectFile>(B), 0);
       const auto SpecifiedCPUType = MachO::getCPUTypeFromArchitecture(
                                         MachO::getArchitectureFromName(
                                             Triple(*IF.ArchType).getArchName()))
@@ -396,8 +396,7 @@
           O.getAsIRObject(LLVMCtx);
       if (IROrError) {
         consumeError(MachOObjOrError.takeError());
-        Expected<Slice> SliceOrErr =
-            Slice::create(IROrError->get(), O.getAlign());
+        Expected<Slice> SliceOrErr = Slice::create(**IROrError, O.getAlign());
         if (!SliceOrErr) {
           reportError(Binary->getFileName(), SliceOrErr.takeError());
           continue;
@@ -409,8 +408,7 @@
       if (ArchiveOrError) {
         consumeError(MachOObjOrError.takeError());
         consumeError(IROrError.takeError());
-        OS << createSliceFromArchive(ArchiveOrError->get()).getArchString()
-           << " ";
+        OS << createSliceFromArchive(**ArchiveOrError).getArchString() << " ";
         continue;
       }
       consumeError(ArchiveOrError.takeError());
@@ -428,7 +426,7 @@
 
   // This should be always the case, as this is tested in readInputBinaries
   const auto *IR = cast<IRObjectFile>(Binary);
-  Expected<Slice> SliceOrErr = createSliceFromIR(IR, 0);
+  Expected<Slice> SliceOrErr = createSliceFromIR(*IR, 0);
   if (!SliceOrErr)
     reportError(IR->getFileName(), SliceOrErr.takeError());
   
@@ -575,21 +573,20 @@
             O.getAsIRObject(LLVMCtx);
         if (IROrError) {
           consumeError(BinaryOrError.takeError());
-          Slice S = createSliceFromIR(
-              static_cast<IRObjectFile *>(IROrError.get().get()), O.getAlign());
+          Slice S = createSliceFromIR(**IROrError, O.getAlign());
           ExtractedObjects.emplace_back(std::move(IROrError.get()));
           Slices.emplace_back(std::move(S));
           continue;
         }
         reportError(InputBinary->getFileName(), BinaryOrError.takeError());
       }
-    } else if (auto O = dyn_cast<MachOObjectFile>(InputBinary)) {
+    } else if (const auto *O = dyn_cast<MachOObjectFile>(InputBinary)) {
       Slices.emplace_back(*O);
-    } else if (auto A = dyn_cast<Archive>(InputBinary)) {
-      Slices.push_back(createSliceFromArchive(A));
+    } else if (const auto *A = dyn_cast<Archive>(InputBinary)) {
+      Slices.push_back(createSliceFromArchive(*A));
     } else if (const auto *IRO = dyn_cast<IRObjectFile>(InputBinary)) {
       // Original Apple's lipo set the alignment to 0
-      Expected<Slice> SliceOrErr = Slice::create(IRO, 0);
+      Expected<Slice> SliceOrErr = Slice::create(*IRO, 0);
       if (!SliceOrErr) {
         reportError(InputBinary->getFileName(), SliceOrErr.takeError());
         continue;