llvm/lib/Object/MachOUniversalWriter.cpp

   1 //===- MachOUniversalWriter.cpp - MachO universal binary writer---*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Defines the Slice class and writeUniversalBinary function for writing a MachO
  10 // universal binary file.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Object/MachOUniversalWriter.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/Object/Archive.h"
  18 #include "llvm/Object/Binary.h"
  19 #include "llvm/Object/IRObjectFile.h"
  20 #include "llvm/Object/MachO.h"
  21 #include "llvm/Object/MachOUniversal.h"
  22 #include "llvm/Support/Casting.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/MathExtras.h"
  26 #include "llvm/Support/MemoryBufferRef.h"
  27 #include "llvm/Support/SwapByteOrder.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include "llvm/TargetParser/Triple.h"
  30
  31 using namespace llvm;
  32 using namespace object;
  33
  34 // For compatibility with cctools lipo, a file's alignment is calculated as the
  35 // minimum aligment of all segments. For object files, the file's alignment is
  36 // the maximum alignment of its sections.
  37 static uint32_t calculateFileAlignment(const MachOObjectFile &O) {
  38   uint32_t P2CurrentAlignment;
  39   uint32_t P2MinAlignment = MachOUniversalBinary::MaxSectionAlignment;
  40   const bool Is64Bit = O.is64Bit();
  41
  42   for (const auto &LC : O.load_commands()) {
  43     if (LC.C.cmd != (Is64Bit ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT))
  44       continue;
  45     if (O.getHeader().filetype == MachO::MH_OBJECT) {
  46       unsigned NumberOfSections =
  47           (Is64Bit ? O.getSegment64LoadCommand(LC).nsects
  48                    : O.getSegmentLoadCommand(LC).nsects);
  49       P2CurrentAlignment = NumberOfSections ? 2 : P2MinAlignment;
  50       for (unsigned SI = 0; SI < NumberOfSections; ++SI) {
  51         P2CurrentAlignment = std::max(P2CurrentAlignment,
  52                                       (Is64Bit ? O.getSection64(LC, SI).align
  53                                                : O.getSection(LC, SI).align));
  54       }
  55     } else {
  56       P2CurrentAlignment =
  57           llvm::countr_zero(Is64Bit ? O.getSegment64LoadCommand(LC).vmaddr
  58                                     : O.getSegmentLoadCommand(LC).vmaddr);
  59     }
  60     P2MinAlignment = std::min(P2MinAlignment, P2CurrentAlignment);
  61   }
  62   // return a value >= 4 byte aligned, and less than MachO MaxSectionAlignment
  63   return std::max(
  64       static_cast<uint32_t>(2),
  65       std::min(P2MinAlignment, static_cast<uint32_t>(
  66                                    MachOUniversalBinary::MaxSectionAlignment)));
  67 }
  68
  69 static uint32_t calculateAlignment(const MachOObjectFile &ObjectFile) {
  70   switch (ObjectFile.getHeader().cputype) {
  71   case MachO::CPU_TYPE_I386:
  72   case MachO::CPU_TYPE_X86_64:
  73   case MachO::CPU_TYPE_POWERPC:
  74   case MachO::CPU_TYPE_POWERPC64:
  75     return 12; // log2 value of page size(4k) for x86 and PPC
  76   case MachO::CPU_TYPE_ARM:
  77   case MachO::CPU_TYPE_ARM64:
  78   case MachO::CPU_TYPE_ARM64_32:
  79     return 14; // log2 value of page size(16k) for Darwin ARM
  80   default:
  81     return calculateFileAlignment(ObjectFile);
  82   }
  83 }
  84
  85 Slice::Slice(const Archive &A, uint32_t CPUType, uint32_t CPUSubType,
  86              std::string ArchName, uint32_t Align)
  87     : B(&A), CPUType(CPUType), CPUSubType(CPUSubType),
  88       ArchName(std::move(ArchName)), P2Alignment(Align) {}
  89
  90 Slice::Slice(const MachOObjectFile &O, uint32_t Align)
  91     : B(&O), CPUType(O.getHeader().cputype),
  92       CPUSubType(O.getHeader().cpusubtype),
  93       ArchName(std::string(O.getArchTriple().getArchName())),
  94       P2Alignment(Align) {}
  95
  96 Slice::Slice(const IRObjectFile &IRO, uint32_t CPUType, uint32_t CPUSubType,
  97              std::string ArchName, uint32_t Align)
  98     : B(&IRO), CPUType(CPUType), CPUSubType(CPUSubType),
  99       ArchName(std::move(ArchName)), P2Alignment(Align) {}
 100
 101 Slice::Slice(const MachOObjectFile &O) : Slice(O, calculateAlignment(O)) {}
 102
 103 using MachoCPUTy = std::pair<uint32_t, uint32_t>;
 104
 105 static Expected<MachoCPUTy> getMachoCPUFromTriple(Triple TT) {
 106   auto CPU = std::make_pair(MachO::getCPUType(TT), MachO::getCPUSubType(TT));
 107   if (!CPU.first) {
 108     return CPU.first.takeError();
 109   }
 110   if (!CPU.second) {
 111     return CPU.second.takeError();
 112   }
 113   return std::make_pair(*CPU.first, *CPU.second);
 114 }
 115
 116 static Expected<MachoCPUTy> getMachoCPUFromTriple(StringRef TT) {
 117   return getMachoCPUFromTriple(Triple{TT});
 118 }
 119
 120 static MachoCPUTy getMachoCPUFromObjectFile(const MachOObjectFile &O) {
 121   return std::make_pair(O.getHeader().cputype, O.getHeader().cpusubtype);
 122 }
 123
 124 Expected<Slice> Slice::create(const Archive &A, LLVMContext *LLVMCtx) {
 125   Error Err = Error::success();
 126   std::unique_ptr<MachOObjectFile> MFO = nullptr;
 127   std::unique_ptr<IRObjectFile> IRFO = nullptr;
 128   std::optional<MachoCPUTy> CPU = std::nullopt;
 129   for (const Archive::Child &Child : A.children(Err)) {
 130     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(LLVMCtx);
 131     if (!ChildOrErr)
 132       return createFileError(A.getFileName(), ChildOrErr.takeError());
 133     Binary *Bin = ChildOrErr.get().get();
 134     if (Bin->isMachOUniversalBinary())
 135       return createStringError(std::errc::invalid_argument,
 136                                ("archive member " + Bin->getFileName() +
 137                                 " is a fat file (not allowed in an archive)")
 138                                    .str()
 139                                    .c_str());
 140     if (Bin->isMachO()) {
 141       MachOObjectFile *O = cast<MachOObjectFile>(Bin);
 142       MachoCPUTy ObjectCPU = getMachoCPUFromObjectFile(*O);
 143
 144       if (CPU && CPU != ObjectCPU) {
 145         // If CPU != nullptr, one of MFO, IRFO will be != nullptr.
 146         StringRef PreviousName = MFO ? MFO->getFileName() : IRFO->getFileName();
 147         return createStringError(
 148             std::errc::invalid_argument,
 149             ("archive member " + O->getFileName() + " cputype (" +
 150              Twine(ObjectCPU.first) + ") and cpusubtype(" +
 151              Twine(ObjectCPU.second) +
 152              ") does not match previous archive members cputype (" +
 153              Twine(CPU->first) + ") and cpusubtype(" + Twine(CPU->second) +
 154              ") (all members must match) " + PreviousName)
 155                 .str()
 156                 .c_str());
 157       }
 158       if (!MFO) {
 159         ChildOrErr.get().release();
 160         MFO.reset(O);
 161         if (!CPU)
 162           CPU.emplace(ObjectCPU);
 163       }
 164     } else if (Bin->isIR()) {
 165       IRObjectFile *O = cast<IRObjectFile>(Bin);
 166       Expected<MachoCPUTy> ObjectCPU =
 167           getMachoCPUFromTriple(O->getTargetTriple());
 168       if (!ObjectCPU)
 169         return ObjectCPU.takeError();
 170
 171       if (CPU && CPU != *ObjectCPU) {
 172         // If CPU != nullptr, one of MFO, IRFO will be != nullptr.
 173         StringRef PreviousName =
 174             IRFO ? IRFO->getFileName() : MFO->getFileName();
 175         return createStringError(
 176             std::errc::invalid_argument,
 177             ("archive member " + O->getFileName() + " cputype (" +
 178              Twine(ObjectCPU->first) + ") and cpusubtype(" +
 179              Twine(ObjectCPU->second) +
 180              ") does not match previous archive members cputype (" +
 181              Twine(CPU->first) + ") and cpusubtype(" + Twine(CPU->second) +
 182              ") (all members must match) " + PreviousName)
 183                 .str()
 184                 .c_str());
 185       }
 186
 187       if (!IRFO) {
 188         ChildOrErr.get().release();
 189         IRFO.reset(O);
 190         if (!CPU)
 191           CPU.emplace(*ObjectCPU);
 192       }
 193     } else
 194       return createStringError(std::errc::invalid_argument,
 195                                ("archive member " + Bin->getFileName() +
 196                                 " is neither a MachO file or an LLVM IR file "
 197                                 "(not allowed in an archive)")
 198                                    .str()
 199                                    .c_str());
 200   }
 201   if (Err)
 202     return createFileError(A.getFileName(), std::move(Err));
 203   if (!MFO && !IRFO)
 204     return createStringError(
 205         std::errc::invalid_argument,
 206         ("empty archive with no architecture specification: " +
 207          A.getFileName() + " (can't determine architecture for it)")
 208             .str()
 209             .c_str());
 210
 211   if (MFO) {
 212     Slice ArchiveSlice(*(MFO), MFO->is64Bit() ? 3 : 2);
 213     ArchiveSlice.B = &A;
 214     return ArchiveSlice;
 215   }
 216
 217   // For IR objects
 218   Expected<Slice> ArchiveSliceOrErr = Slice::create(*IRFO, 0);
 219   if (!ArchiveSliceOrErr)
 220     return createFileError(A.getFileName(), ArchiveSliceOrErr.takeError());
 221   auto &ArchiveSlice = ArchiveSliceOrErr.get();
 222   ArchiveSlice.B = &A;
 223   return std::move(ArchiveSlice);
 224 }
 225
 226 Expected<Slice> Slice::create(const IRObjectFile &IRO, uint32_t Align) {
 227   Expected<MachoCPUTy> CPUOrErr = getMachoCPUFromTriple(IRO.getTargetTriple());
 228   if (!CPUOrErr)
 229     return CPUOrErr.takeError();
 230   unsigned CPUType, CPUSubType;
 231   std::tie(CPUType, CPUSubType) = CPUOrErr.get();
 232   // We don't directly use the architecture name of the target triple T, as,
 233   // for instance, thumb is treated as ARM by the MachOUniversal object.
 234   std::string ArchName(
 235       MachOObjectFile::getArchTriple(CPUType, CPUSubType).getArchName());
 236   return Slice{IRO, CPUType, CPUSubType, std::move(ArchName), Align};
 237 }
 238
 239 template <typename FatArchTy> struct FatArchTraits {
 240   static const uint64_t OffsetLimit;
 241   static const std::string StructName;
 242   static const uint8_t BitCount;
 243 };
 244
 245 template <> struct FatArchTraits<MachO::fat_arch> {
 246   static const uint64_t OffsetLimit = UINT32_MAX;
 247   static const std::string StructName;
 248   static const uint8_t BitCount = 32;
 249 };
 250 const std::string FatArchTraits<MachO::fat_arch>::StructName = "fat_arch";
 251
 252 template <> struct FatArchTraits<MachO::fat_arch_64> {
 253   static const uint64_t OffsetLimit = UINT64_MAX;
 254   static const std::string StructName;
 255   static const uint8_t BitCount = 64;
 256 };
 257 const std::string FatArchTraits<MachO::fat_arch_64>::StructName = "fat_arch_64";
 258
 259 template <typename FatArchTy>
 260 static Expected<SmallVector<FatArchTy, 2>>
 261 buildFatArchList(ArrayRef<Slice> Slices) {
 262   SmallVector<FatArchTy, 2> FatArchList;
 263   uint64_t Offset =
 264       sizeof(MachO::fat_header) + Slices.size() * sizeof(FatArchTy);
 265
 266   for (const auto &S : Slices) {
 267     Offset = alignTo(Offset, 1ull << S.getP2Alignment());
 268     if (Offset > FatArchTraits<FatArchTy>::OffsetLimit)
 269       return createStringError(
 270           std::errc::invalid_argument,
 271           ("fat file too large to be created because the offset field in the "
 272            "struct " +
 273            Twine(FatArchTraits<FatArchTy>::StructName) + " is only " +
 274            Twine(FatArchTraits<FatArchTy>::BitCount) + "-bits and the offset " +
 275            Twine(Offset) + " for " + S.getBinary()->getFileName() +
 276            " for architecture " + S.getArchString() + "exceeds that.")
 277               .str()
 278               .c_str());
 279
 280     FatArchTy FatArch = {};
 281     FatArch.cputype = S.getCPUType();
 282     FatArch.cpusubtype = S.getCPUSubType();
 283     FatArch.offset = Offset;
 284     FatArch.size = S.getBinary()->getMemoryBufferRef().getBufferSize();
 285     FatArch.align = S.getP2Alignment();
 286     Offset += FatArch.size;
 287     FatArchList.push_back(FatArch);
 288   }
 289   return FatArchList;
 290 }
 291
 292 template <typename FatArchTy>
 293 static Error writeUniversalArchsToStream(MachO::fat_header FatHeader,
 294                                          ArrayRef<Slice> Slices,
 295                                          raw_ostream &Out) {
 296   Expected<SmallVector<FatArchTy, 2>> FatArchListOrErr =
 297       buildFatArchList<FatArchTy>(Slices);
 298   if (!FatArchListOrErr)
 299     return FatArchListOrErr.takeError();
 300   SmallVector<FatArchTy, 2> FatArchList = *FatArchListOrErr;
 301
 302   if (sys::IsLittleEndianHost)
 303     MachO::swapStruct(FatHeader);
 304   Out.write(reinterpret_cast<const char *>(&FatHeader),
 305             sizeof(MachO::fat_header));
 306
 307   if (sys::IsLittleEndianHost)
 308     for (FatArchTy &FA : FatArchList)
 309       MachO::swapStruct(FA);
 310   Out.write(reinterpret_cast<const char *>(FatArchList.data()),
 311             sizeof(FatArchTy) * FatArchList.size());
 312
 313   if (sys::IsLittleEndianHost)
 314     for (FatArchTy &FA : FatArchList)
 315       MachO::swapStruct(FA);
 316
 317   size_t Offset =
 318       sizeof(MachO::fat_header) + sizeof(FatArchTy) * FatArchList.size();
 319   for (size_t Index = 0, Size = Slices.size(); Index < Size; ++Index) {
 320     MemoryBufferRef BufferRef = Slices[Index].getBinary()->getMemoryBufferRef();
 321     assert((Offset <= FatArchList[Index].offset) && "Incorrect slice offset");
 322     Out.write_zeros(FatArchList[Index].offset - Offset);
 323     Out.write(BufferRef.getBufferStart(), BufferRef.getBufferSize());
 324     Offset = FatArchList[Index].offset + BufferRef.getBufferSize();
 325   }
 326
 327   Out.flush();
 328   return Error::success();
 329 }
 330
 331 Error object::writeUniversalBinaryToStream(ArrayRef<Slice> Slices,
 332                                            raw_ostream &Out,
 333                                            FatHeaderType HeaderType) {
 334   MachO::fat_header FatHeader;
 335   FatHeader.nfat_arch = Slices.size();
 336
 337   switch (HeaderType) {
 338   case FatHeaderType::Fat64Header:
 339     FatHeader.magic = MachO::FAT_MAGIC_64;
 340     return writeUniversalArchsToStream<MachO::fat_arch_64>(FatHeader, Slices,
 341                                                            Out);
 342     break;
 343   case FatHeaderType::FatHeader:
 344     FatHeader.magic = MachO::FAT_MAGIC;
 345     return writeUniversalArchsToStream<MachO::fat_arch>(FatHeader, Slices, Out);
 346     break;
 347   }
 348
 349   llvm_unreachable("Invalid fat header type");
 350 }
 351
 352 Error object::writeUniversalBinary(ArrayRef<Slice> Slices,
 353                                    StringRef OutputFileName,
 354                                    FatHeaderType HeaderType) {
 355   const bool IsExecutable = any_of(Slices, [](Slice S) {
 356     return sys::fs::can_execute(S.getBinary()->getFileName());
 357   });
 358   unsigned Mode = sys::fs::all_read | sys::fs::all_write;
 359   if (IsExecutable)
 360     Mode |= sys::fs::all_exe;
 361   Expected<sys::fs::TempFile> Temp = sys::fs::TempFile::create(
 362       OutputFileName + ".temp-universal-%%%%%%", Mode);
 363   if (!Temp)
 364     return Temp.takeError();
 365   raw_fd_ostream Out(Temp->FD, false);
 366   if (Error E = writeUniversalBinaryToStream(Slices, Out, HeaderType)) {
 367     if (Error DiscardError = Temp->discard())
 368       return joinErrors(std::move(E), std::move(DiscardError));
 369     return E;
 370   }
 371   return Temp->keep(OutputFileName);
 372 }