[Object][MachO] Refine interface of Slice

[alexander-shaposhnikov]

Summary

This patch performs a minor cleanup of the class Slice:
static methods and constructors which take a pointer but assume that it's not null now take the argument by reference.
NFC.

Test plan: make check-all

[alexander-shaposhnikov]

Apply clang-format

llvm/include/llvm/Object/MachOUniversalWriter.h

class Slice {
   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,
+  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 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; }
 
   const Binary *getBinary() const { return B; }
 
   uint32_t getCPUType() const { return CPUType; }
 
   uint32_t getCPUSubType() const { return CPUSubType; }

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,
+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)) {}
 
 using MachoCPUTy = std::pair<unsigned, unsigned>;
 
 static Expected<MachoCPUTy> getMachoCPUFromTriple(Triple TT) {
   auto CPU = std::make_pair(MachO::getCPUType(TT), MachO::getCPUSubType(TT));
   if (!CPU.first) {
     return CPU.first.takeError();
   }
   if (!CPU.second) {
     return CPU.second.takeError();
   }
   return std::make_pair(*CPU.first, *CPU.second);
 }
 
 static Expected<MachoCPUTy> getMachoCPUFromTriple(StringRef TT) {
   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,
                                ("archive member " + Bin->getFileName() +
                                 " is a fat file (not allowed in an archive)")
                                    .str()
                                    .c_str());
     if (Bin->isMachO()) {
if (Bin->isMachO()) {
       return createStringError(std::errc::invalid_argument,
                                ("archive member " + Bin->getFileName() +
                                 " is neither a MachO file or an LLVM IR file "
                                 "(not allowed in an archive)")
                                    .str()
                                    .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;
   std::tie(CPUType, CPUSubType) = CPUOrErr.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());

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

static Error addMember(MembersPerArchitectureMap &Members,
   return Error::success();
 }
 
 static Expected<SmallVector<Slice, 2>>
 buildSlices(ArrayRef<OwningBinary<Archive>> OutputBinaries) {
   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();
     Slices.push_back(*ArchiveSlice);
   }
   return Slices;
 }
 

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

struct Config {
   SmallVector<std::string, 1> VerifyArchList;
   SmallVector<InputFile, 1> ReplacementFiles;
   StringMap<const uint32_t> SegmentAlignments;
   std::string ArchType;
   std::string OutputFile;
   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;
 }
 
 } // end namespace
 
 static void validateArchitectureName(StringRef ArchitectureName) {
   if (!MachOObjectFile::isValidArch(ArchitectureName)) {
     std::string Buf;
for (const InputFile &IF : InputFiles) {
     const Binary *B = BinaryOrErr->getBinary();
     if (!B->isArchive() && !B->isMachO() && !B->isMachOUniversalBinary() &&
         !B->isIR())
       reportError("File " + IF.FileName + " has unsupported binary format");
     if (IF.ArchType && (B->isMachO() || B->isArchive() || B->isIR())) {
       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()))
                                         .first;
       // For compatibility with cctools' lipo the comparison is relaxed just to
       // checking cputypes.
       if (S.getCPUType() != SpecifiedCPUType)
         reportError("specified architecture: " + *IF.ArchType +
for (const auto &O : UO->objects()) {
       if (MachOObjOrError) {
         OS << Slice(*(MachOObjOrError->get())).getArchString() << " ";
         continue;
       }
       Expected<std::unique_ptr<IRObjectFile>> IROrError =
           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;
         }
         OS << SliceOrErr.get().getArchString() << " ";
         continue;
       }
       Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive();
       if (ArchiveOrError) {
         consumeError(MachOObjOrError.takeError());
         consumeError(IROrError.takeError());
-        OS << createSliceFromArchive(ArchiveOrError->get()).getArchString()
-           << " ";
+        OS << createSliceFromArchive(**ArchiveOrError).getArchString() << " ";
         continue;
       }
       consumeError(ArchiveOrError.takeError());
       reportError(Binary->getFileName(), MachOObjOrError.takeError());
       reportError(Binary->getFileName(), IROrError.takeError());
     }
     OS << "\n";
     return;
   }
 
   if (const auto *MachO = dyn_cast<MachOObjectFile>(Binary)) {
     OS << Slice(*MachO).getArchString() << " \n";
     return;
   }
 
   // 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());
   
   OS << SliceOrErr->getArchString() << " \n";
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void printArchs(ArrayRef<OwningBinary<Binary>> InputBinaries) {
if (auto UO = dyn_cast<MachOUniversalBinary>(InputBinary)) {
           Slices.emplace_back(*(BinaryOrError.get()), O.getAlign());
           ExtractedObjects.push_back(std::move(BinaryOrError.get()));
           continue;
         }
         Expected<std::unique_ptr<IRObjectFile>> IROrError =
             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;
       }
       Slices.emplace_back(std::move(SliceOrErr.get()));
     } else {
       llvm_unreachable("Unexpected binary format");
     }