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