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.
calculateFileAlignment(const MachOObjectFile & O)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 
calculateAlignment(const MachOObjectFile & ObjectFile)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 
Slice(const Archive & A,uint32_t CPUType,uint32_t CPUSubType,std::string ArchName,uint32_t Align)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 
Slice(const MachOObjectFile & O,uint32_t Align)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 
Slice(const IRObjectFile & IRO,uint32_t CPUType,uint32_t CPUSubType,std::string ArchName,uint32_t Align)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 
Slice(const MachOObjectFile & O)101 Slice::Slice(const MachOObjectFile &O) : Slice(O, calculateAlignment(O)) {}
102 
103 using MachoCPUTy = std::pair<uint32_t, uint32_t>;
104 
getMachoCPUFromTriple(Triple TT)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 
getMachoCPUFromTriple(StringRef TT)116 static Expected<MachoCPUTy> getMachoCPUFromTriple(StringRef TT) {
117   return getMachoCPUFromTriple(Triple{TT});
118 }
119 
getMachoCPUFromObjectFile(const MachOObjectFile & O)120 static MachoCPUTy getMachoCPUFromObjectFile(const MachOObjectFile &O) {
121   return std::make_pair(O.getHeader().cputype, O.getHeader().cpusubtype);
122 }
123 
create(const Archive & A,LLVMContext * LLVMCtx)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 
create(const IRObjectFile & IRO,uint32_t Align)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>>
buildFatArchList(ArrayRef<Slice> Slices)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>
writeUniversalArchsToStream(MachO::fat_header FatHeader,ArrayRef<Slice> Slices,raw_ostream & Out)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 
writeUniversalBinaryToStream(ArrayRef<Slice> Slices,raw_ostream & Out,FatHeaderType HeaderType)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 
writeUniversalBinary(ArrayRef<Slice> Slices,StringRef OutputFileName,FatHeaderType HeaderType)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 }
373