1 //===- MachOUniversalWriter.cpp - MachO universal binary writer---*- C++-*-===//
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
7 //===----------------------------------------------------------------------===//
9 // Defines the Slice class and writeUniversalBinary function for writing a MachO
10 // universal binary file.
12 //===----------------------------------------------------------------------===//
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"
32 using namespace object;
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();
42 for (const auto &LC : O.load_commands()) {
43 if (LC.C.cmd != (Is64Bit ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT))
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));
57 llvm::countr_zero(Is64Bit ? O.getSegment64LoadCommand(LC).vmaddr
58 : O.getSegmentLoadCommand(LC).vmaddr);
60 P2MinAlignment = std::min(P2MinAlignment, P2CurrentAlignment);
62 // return a value >= 4 byte aligned, and less than MachO MaxSectionAlignment
64 static_cast<uint32_t>(2),
65 std::min(P2MinAlignment, static_cast<uint32_t>(
66 MachOUniversalBinary::MaxSectionAlignment)));
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
81 return calculateFileAlignment(ObjectFile);
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) {}
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())),
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) {}
101 Slice::Slice(const MachOObjectFile &O) : Slice(O, calculateAlignment(O)) {}
103 using MachoCPUTy = std::pair<unsigned, unsigned>;
105 static Expected<MachoCPUTy> getMachoCPUFromTriple(Triple TT) {
106 auto CPU = std::make_pair(MachO::getCPUType(TT), MachO::getCPUSubType(TT));
108 return CPU.first.takeError();
111 return CPU.second.takeError();
113 return std::make_pair(*CPU.first, *CPU.second);
116 static Expected<MachoCPUTy> getMachoCPUFromTriple(StringRef TT) {
117 return getMachoCPUFromTriple(Triple{TT});
120 Expected<Slice> Slice::create(const Archive &A, LLVMContext *LLVMCtx) {
121 Error Err = Error::success();
122 std::unique_ptr<MachOObjectFile> MFO = nullptr;
123 std::unique_ptr<IRObjectFile> IRFO = nullptr;
124 for (const Archive::Child &Child : A.children(Err)) {
125 Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(LLVMCtx);
127 return createFileError(A.getFileName(), ChildOrErr.takeError());
128 Binary *Bin = ChildOrErr.get().get();
129 if (Bin->isMachOUniversalBinary())
130 return createStringError(std::errc::invalid_argument,
131 ("archive member " + Bin->getFileName() +
132 " is a fat file (not allowed in an archive)")
135 if (Bin->isMachO()) {
136 MachOObjectFile *O = cast<MachOObjectFile>(Bin);
138 return createStringError(
139 std::errc::invalid_argument,
140 "archive member %s is a MachO, while previous archive member "
141 "%s was an IR LLVM object",
142 O->getFileName().str().c_str(), IRFO->getFileName().str().c_str());
145 std::tie(MFO->getHeader().cputype, MFO->getHeader().cpusubtype) !=
146 std::tie(O->getHeader().cputype, O->getHeader().cpusubtype)) {
147 return createStringError(
148 std::errc::invalid_argument,
149 ("archive member " + O->getFileName() + " cputype (" +
150 Twine(O->getHeader().cputype) + ") and cpusubtype(" +
151 Twine(O->getHeader().cpusubtype) +
152 ") does not match previous archive members cputype (" +
153 Twine(MFO->getHeader().cputype) + ") and cpusubtype(" +
154 Twine(MFO->getHeader().cpusubtype) +
155 ") (all members must match) " + MFO->getFileName())
160 ChildOrErr.get().release();
163 } else if (Bin->isIR()) {
164 IRObjectFile *O = cast<IRObjectFile>(Bin);
166 return createStringError(std::errc::invalid_argument,
167 "archive member '%s' is an LLVM IR object, "
168 "while previous archive member "
170 O->getFileName().str().c_str(),
171 MFO->getFileName().str().c_str());
174 Expected<MachoCPUTy> CPUO = getMachoCPUFromTriple(O->getTargetTriple());
175 Expected<MachoCPUTy> CPUFO =
176 getMachoCPUFromTriple(IRFO->getTargetTriple());
178 return CPUO.takeError();
180 return CPUFO.takeError();
181 if (*CPUO != *CPUFO) {
182 return createStringError(
183 std::errc::invalid_argument,
184 ("archive member " + O->getFileName() + " cputype (" +
185 Twine(CPUO->first) + ") and cpusubtype(" + Twine(CPUO->second) +
186 ") does not match previous archive members cputype (" +
187 Twine(CPUFO->first) + ") and cpusubtype(" +
188 Twine(CPUFO->second) + ") (all members must match) " +
194 ChildOrErr.get().release();
198 return createStringError(std::errc::invalid_argument,
199 ("archive member " + Bin->getFileName() +
200 " is neither a MachO file or an LLVM IR file "
201 "(not allowed in an archive)")
206 return createFileError(A.getFileName(), std::move(Err));
208 return createStringError(
209 std::errc::invalid_argument,
210 ("empty archive with no architecture specification: " +
211 A.getFileName() + " (can't determine architecture for it)")
216 Slice ArchiveSlice(*(MFO), MFO->is64Bit() ? 3 : 2);
222 Expected<Slice> ArchiveSliceOrErr = Slice::create(*IRFO, 0);
223 if (!ArchiveSliceOrErr)
224 return createFileError(A.getFileName(), ArchiveSliceOrErr.takeError());
225 auto &ArchiveSlice = ArchiveSliceOrErr.get();
227 return std::move(ArchiveSlice);
230 Expected<Slice> Slice::create(const IRObjectFile &IRO, uint32_t Align) {
231 Expected<MachoCPUTy> CPUOrErr = getMachoCPUFromTriple(IRO.getTargetTriple());
233 return CPUOrErr.takeError();
234 unsigned CPUType, CPUSubType;
235 std::tie(CPUType, CPUSubType) = CPUOrErr.get();
236 // We don't directly use the architecture name of the target triple T, as,
237 // for instance, thumb is treated as ARM by the MachOUniversal object.
238 std::string ArchName(
239 MachOObjectFile::getArchTriple(CPUType, CPUSubType).getArchName());
240 return Slice{IRO, CPUType, CPUSubType, std::move(ArchName), Align};
243 static Expected<SmallVector<MachO::fat_arch, 2>>
244 buildFatArchList(ArrayRef<Slice> Slices) {
245 SmallVector<MachO::fat_arch, 2> FatArchList;
247 sizeof(MachO::fat_header) + Slices.size() * sizeof(MachO::fat_arch);
249 for (const auto &S : Slices) {
250 Offset = alignTo(Offset, 1ull << S.getP2Alignment());
251 if (Offset > UINT32_MAX)
252 return createStringError(
253 std::errc::invalid_argument,
254 ("fat file too large to be created because the offset "
255 "field in struct fat_arch is only 32-bits and the offset " +
256 Twine(Offset) + " for " + S.getBinary()->getFileName() +
257 " for architecture " + S.getArchString() + "exceeds that.")
261 MachO::fat_arch FatArch;
262 FatArch.cputype = S.getCPUType();
263 FatArch.cpusubtype = S.getCPUSubType();
264 FatArch.offset = Offset;
265 FatArch.size = S.getBinary()->getMemoryBufferRef().getBufferSize();
266 FatArch.align = S.getP2Alignment();
267 Offset += FatArch.size;
268 FatArchList.push_back(FatArch);
273 Error object::writeUniversalBinaryToStream(ArrayRef<Slice> Slices,
275 MachO::fat_header FatHeader;
276 FatHeader.magic = MachO::FAT_MAGIC;
277 FatHeader.nfat_arch = Slices.size();
279 Expected<SmallVector<MachO::fat_arch, 2>> FatArchListOrErr =
280 buildFatArchList(Slices);
281 if (!FatArchListOrErr)
282 return FatArchListOrErr.takeError();
283 SmallVector<MachO::fat_arch, 2> FatArchList = *FatArchListOrErr;
285 if (sys::IsLittleEndianHost)
286 MachO::swapStruct(FatHeader);
287 Out.write(reinterpret_cast<const char *>(&FatHeader),
288 sizeof(MachO::fat_header));
290 if (sys::IsLittleEndianHost)
291 for (MachO::fat_arch &FA : FatArchList)
292 MachO::swapStruct(FA);
293 Out.write(reinterpret_cast<const char *>(FatArchList.data()),
294 sizeof(MachO::fat_arch) * FatArchList.size());
296 if (sys::IsLittleEndianHost)
297 for (MachO::fat_arch &FA : FatArchList)
298 MachO::swapStruct(FA);
301 sizeof(MachO::fat_header) + sizeof(MachO::fat_arch) * FatArchList.size();
302 for (size_t Index = 0, Size = Slices.size(); Index < Size; ++Index) {
303 MemoryBufferRef BufferRef = Slices[Index].getBinary()->getMemoryBufferRef();
304 assert((Offset <= FatArchList[Index].offset) && "Incorrect slice offset");
305 Out.write_zeros(FatArchList[Index].offset - Offset);
306 Out.write(BufferRef.getBufferStart(), BufferRef.getBufferSize());
307 Offset = FatArchList[Index].offset + BufferRef.getBufferSize();
311 return Error::success();
314 Error object::writeUniversalBinary(ArrayRef<Slice> Slices,
315 StringRef OutputFileName) {
316 const bool IsExecutable = any_of(Slices, [](Slice S) {
317 return sys::fs::can_execute(S.getBinary()->getFileName());
319 unsigned Mode = sys::fs::all_read | sys::fs::all_write;
321 Mode |= sys::fs::all_exe;
322 Expected<sys::fs::TempFile> Temp = sys::fs::TempFile::create(
323 OutputFileName + ".temp-universal-%%%%%%", Mode);
325 return Temp.takeError();
326 raw_fd_ostream Out(Temp->FD, false);
327 if (Error E = writeUniversalBinaryToStream(Slices, Out)) {
328 if (Error DiscardError = Temp->discard())
329 return joinErrors(std::move(E), std::move(DiscardError));
332 return Temp->keep(OutputFileName);