1//===- ArchiveWriter.cpp - ar File Format implementation --------*- 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// This file defines the writeArchive function.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Object/ArchiveWriter.h"
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/StringMap.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/BinaryFormat/Magic.h"
18#include "llvm/IR/LLVMContext.h"
19#include "llvm/Object/Archive.h"
20#include "llvm/Object/COFF.h"
21#include "llvm/Object/COFFImportFile.h"
22#include "llvm/Object/Error.h"
23#include "llvm/Object/GOFFObjectFile.h"
24#include "llvm/Object/IRObjectFile.h"
25#include "llvm/Object/MachO.h"
26#include "llvm/Object/ObjectFile.h"
27#include "llvm/Object/SymbolicFile.h"
28#include "llvm/Object/XCOFFObjectFile.h"
29#include "llvm/Support/Alignment.h"
30#include "llvm/Support/EndianStream.h"
31#include "llvm/Support/Errc.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/Format.h"
34#include "llvm/Support/MathExtras.h"
35#include "llvm/Support/Path.h"
36#include "llvm/Support/SmallVectorMemoryBuffer.h"
37#include "llvm/Support/raw_ostream.h"
38
39#include <cerrno>
40#include <map>
41
42#if !defined(_MSC_VER) && !defined(__MINGW32__)
43#include <unistd.h>
44#else
45#include <io.h>
46#endif
47
48using namespace llvm;
49using namespace llvm::object;
50
51struct SymMap {
52 bool UseECMap = false;
53 std::map<std::string, uint16_t> Map;
54 std::map<std::string, uint16_t> ECMap;
55};
56
57NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef)
58 : Buf(MemoryBuffer::getMemBuffer(Ref: BufRef, RequiresNullTerminator: false)),
59 MemberName(BufRef.getBufferIdentifier()) {}
60
61object::Archive::Kind NewArchiveMember::detectKindFromObject() const {
62 auto MemBufferRef = this->Buf->getMemBufferRef();
63 Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =
64 object::ObjectFile::createObjectFile(Object: MemBufferRef);
65
66 if (OptionalObject) {
67 if (isa<object::MachOObjectFile>(Val: **OptionalObject))
68 return object::Archive::K_DARWIN;
69 if (isa<object::XCOFFObjectFile>(Val: **OptionalObject))
70 return object::Archive::K_AIXBIG;
71 if (isa<object::COFFObjectFile>(Val: **OptionalObject) ||
72 isa<object::COFFImportFile>(Val: **OptionalObject))
73 return object::Archive::K_COFF;
74 if (isa<object::GOFFObjectFile>(Val: **OptionalObject))
75 return object::Archive::K_ZOS;
76 return object::Archive::K_GNU;
77 }
78
79 // Squelch the error in case we had a non-object file.
80 consumeError(Err: OptionalObject.takeError());
81
82 // If we're adding a bitcode file to the archive, detect the Archive kind
83 // based on the target triple.
84 LLVMContext Context;
85 if (identify_magic(magic: MemBufferRef.getBuffer()) == file_magic::bitcode) {
86 if (auto ObjOrErr = object::SymbolicFile::createSymbolicFile(
87 Object: MemBufferRef, Type: file_magic::bitcode, Context: &Context)) {
88 auto &IRObject = cast<object::IRObjectFile>(Val&: **ObjOrErr);
89 auto TargetTriple = Triple(IRObject.getTargetTriple());
90 return object::Archive::getDefaultKindForTriple(T: TargetTriple);
91 } else {
92 // Squelch the error in case this was not a SymbolicFile.
93 consumeError(Err: ObjOrErr.takeError());
94 }
95 }
96
97 return object::Archive::getDefaultKind();
98}
99
100Expected<NewArchiveMember>
101NewArchiveMember::getOldMember(const object::Archive::Child &OldMember,
102 bool Deterministic) {
103 Expected<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef();
104 if (!BufOrErr)
105 return BufOrErr.takeError();
106
107 NewArchiveMember M;
108 M.Buf = MemoryBuffer::getMemBuffer(Ref: *BufOrErr, RequiresNullTerminator: false);
109 M.MemberName = M.Buf->getBufferIdentifier();
110 if (!Deterministic) {
111 auto ModTimeOrErr = OldMember.getLastModified();
112 if (!ModTimeOrErr)
113 return ModTimeOrErr.takeError();
114 M.ModTime = ModTimeOrErr.get();
115 Expected<unsigned> UIDOrErr = OldMember.getUID();
116 if (!UIDOrErr)
117 return UIDOrErr.takeError();
118 M.UID = UIDOrErr.get();
119 Expected<unsigned> GIDOrErr = OldMember.getGID();
120 if (!GIDOrErr)
121 return GIDOrErr.takeError();
122 M.GID = GIDOrErr.get();
123 Expected<sys::fs::perms> AccessModeOrErr = OldMember.getAccessMode();
124 if (!AccessModeOrErr)
125 return AccessModeOrErr.takeError();
126 M.Perms = AccessModeOrErr.get();
127 }
128 return std::move(M);
129}
130
131Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
132 bool Deterministic) {
133 sys::fs::file_status Status;
134 auto FDOrErr = sys::fs::openNativeFileForRead(Name: FileName);
135 if (!FDOrErr)
136 return FDOrErr.takeError();
137 sys::fs::file_t FD = *FDOrErr;
138 assert(FD != sys::fs::kInvalidFile);
139
140 if (auto EC = sys::fs::status(FD, Result&: Status))
141 return errorCodeToError(EC);
142
143 // Opening a directory doesn't make sense. Let it fail.
144 // Linux cannot open directories with open(2), although
145 // cygwin and *bsd can.
146 if (Status.type() == sys::fs::file_type::directory_file)
147 return errorCodeToError(EC: make_error_code(E: errc::is_a_directory));
148
149 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
150 MemoryBuffer::getOpenFile(FD, Filename: FileName, FileSize: Status.getSize(), RequiresNullTerminator: false);
151 if (!MemberBufferOrErr)
152 return errorCodeToError(EC: MemberBufferOrErr.getError());
153
154 if (auto EC = sys::fs::closeFile(F&: FD))
155 return errorCodeToError(EC);
156
157 NewArchiveMember M;
158 M.Buf = std::move(*MemberBufferOrErr);
159 M.MemberName = M.Buf->getBufferIdentifier();
160 if (!Deterministic) {
161 M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>(
162 t: Status.getLastModificationTime());
163 M.UID = Status.getUser();
164 M.GID = Status.getGroup();
165 M.Perms = Status.permissions();
166 }
167 return std::move(M);
168}
169
170template <typename T>
171static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) {
172 uint64_t OldPos = OS.tell();
173 OS << Data;
174 unsigned SizeSoFar = OS.tell() - OldPos;
175 assert(SizeSoFar <= Size && "Data doesn't fit in Size");
176 OS.indent(NumSpaces: Size - SizeSoFar);
177}
178
179static bool isDarwin(object::Archive::Kind Kind) {
180 return Kind == object::Archive::K_DARWIN ||
181 Kind == object::Archive::K_DARWIN64;
182}
183
184static bool isAIXBigArchive(object::Archive::Kind Kind) {
185 return Kind == object::Archive::K_AIXBIG;
186}
187
188static bool isCOFFArchive(object::Archive::Kind Kind) {
189 return Kind == object::Archive::K_COFF;
190}
191
192static bool isZOSArchive(object::Archive::Kind Kind) {
193 return Kind == object::Archive::K_ZOS;
194}
195
196static bool isBSDLike(object::Archive::Kind Kind) {
197 switch (Kind) {
198 case object::Archive::K_GNU:
199 case object::Archive::K_GNU64:
200 case object::Archive::K_AIXBIG:
201 case object::Archive::K_COFF:
202 case object::Archive::K_ZOS:
203 return false;
204 case object::Archive::K_BSD:
205 case object::Archive::K_DARWIN:
206 case object::Archive::K_DARWIN64:
207 return true;
208 }
209 llvm_unreachable("not supported for writting");
210}
211
212template <class T>
213static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) {
214 support::endian::write(Out, Val,
215 isBSDLike(Kind) ? llvm::endianness::little
216 : llvm::endianness::big);
217}
218
219template <class T> static void printLE(raw_ostream &Out, T Val) {
220 support::endian::write(Out, Val, llvm::endianness::little);
221}
222
223static void printRestOfMemberHeader(
224 raw_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime,
225 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) {
226 printWithSpacePadding(OS&: Out, Data: sys::toTimeT(TP: ModTime), Size: 12);
227
228 // The format has only 6 chars for uid and gid. Truncate if the provided
229 // values don't fit.
230 printWithSpacePadding(OS&: Out, Data: UID % 1000000, Size: 6);
231 printWithSpacePadding(OS&: Out, Data: GID % 1000000, Size: 6);
232
233 printWithSpacePadding(OS&: Out, Data: format(Fmt: "%o", Vals: Perms), Size: 8);
234 printWithSpacePadding(OS&: Out, Data: Size, Size: 10);
235 Out << "`\n";
236}
237
238static void
239printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name,
240 const sys::TimePoint<std::chrono::seconds> &ModTime,
241 unsigned UID, unsigned GID, unsigned Perms,
242 uint64_t Size) {
243 printWithSpacePadding(OS&: Out, Data: Twine(Name) + "/", Size: 16);
244 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
245}
246
247static void
248printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name,
249 const sys::TimePoint<std::chrono::seconds> &ModTime,
250 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) {
251 uint64_t PosAfterHeader = Pos + 60 + Name.size();
252 // Pad so that even 64 bit object files are aligned.
253 unsigned Pad = offsetToAlignment(Value: PosAfterHeader, Alignment: Align(8));
254 unsigned NameWithPadding = Name.size() + Pad;
255 printWithSpacePadding(OS&: Out, Data: Twine("#1/") + Twine(NameWithPadding), Size: 16);
256 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms,
257 Size: NameWithPadding + Size);
258 Out << Name;
259 while (Pad--)
260 Out.write(C: uint8_t(0));
261}
262
263static void
264printZOSMemberHeader(raw_ostream &Out, StringRef Name,
265 const sys::TimePoint<std::chrono::seconds> &ModTime,
266 unsigned UID, unsigned GID, unsigned Perms,
267 uint64_t Size) {
268 std::string AHeader;
269 raw_string_ostream AOut(AHeader);
270 if (Name.size() <= 16) {
271 printWithSpacePadding(OS&: AOut, Data: Twine(Name), Size: 16);
272 printRestOfMemberHeader(Out&: AOut, ModTime, UID, GID, Perms, Size);
273 } else {
274 // z/OS ar stores the exact name length inline with no extra alignment
275 // padding, unlike the BSD format which pads to an 8-byte boundary.
276 printWithSpacePadding(OS&: AOut, Data: Twine("#1/") + Twine(Name.size()), Size: 16);
277 printRestOfMemberHeader(Out&: AOut, ModTime, UID, GID, Perms, Size: Name.size() + Size);
278 AOut << Name;
279 }
280 SmallString<256> EHeader;
281 if (std::error_code EC = ConverterEBCDIC::convertToEBCDIC(Source: AHeader, Result&: EHeader))
282 report_fatal_error(
283 reason: Twine("failed to convert z/OS member header to EBCDIC: ") +
284 EC.message());
285 Out << EHeader.str();
286}
287
288static void
289printBigArchiveMemberHeader(raw_ostream &Out, StringRef Name,
290 const sys::TimePoint<std::chrono::seconds> &ModTime,
291 unsigned UID, unsigned GID, unsigned Perms,
292 uint64_t Size, uint64_t PrevOffset,
293 uint64_t NextOffset) {
294 unsigned NameLen = Name.size();
295
296 printWithSpacePadding(OS&: Out, Data: Size, Size: 20); // File member size
297 printWithSpacePadding(OS&: Out, Data: NextOffset, Size: 20); // Next member header offset
298 printWithSpacePadding(OS&: Out, Data: PrevOffset, Size: 20); // Previous member header offset
299 printWithSpacePadding(OS&: Out, Data: sys::toTimeT(TP: ModTime), Size: 12); // File member date
300 // The big archive format has 12 chars for uid and gid.
301 printWithSpacePadding(OS&: Out, Data: UID % 1000000000000, Size: 12); // UID
302 printWithSpacePadding(OS&: Out, Data: GID % 1000000000000, Size: 12); // GID
303 printWithSpacePadding(OS&: Out, Data: format(Fmt: "%o", Vals: Perms), Size: 12); // Permission
304 printWithSpacePadding(OS&: Out, Data: NameLen, Size: 4); // Name length
305 if (NameLen) {
306 printWithSpacePadding(OS&: Out, Data: Name, Size: NameLen); // Name
307 if (NameLen % 2)
308 Out.write(C: uint8_t(0)); // Null byte padding
309 }
310 Out << "`\n"; // Terminator
311}
312
313static bool useStringTable(bool Thin, StringRef Name) {
314 return Thin || Name.size() >= 16 || Name.contains(C: '/');
315}
316
317static bool is64BitKind(object::Archive::Kind Kind) {
318 switch (Kind) {
319 case object::Archive::K_GNU:
320 case object::Archive::K_BSD:
321 case object::Archive::K_DARWIN:
322 case object::Archive::K_COFF:
323 case object::Archive::K_ZOS:
324 return false;
325 case object::Archive::K_AIXBIG:
326 case object::Archive::K_DARWIN64:
327 case object::Archive::K_GNU64:
328 return true;
329 }
330 llvm_unreachable("not supported for writting");
331}
332
333static void
334printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable,
335 StringMap<uint64_t> &MemberNames, object::Archive::Kind Kind,
336 bool Thin, const NewArchiveMember &M, StringRef MemberName,
337 sys::TimePoint<std::chrono::seconds> ModTime, uint64_t Size) {
338 if (isBSDLike(Kind))
339 return printBSDMemberHeader(Out, Pos, Name: MemberName, ModTime, UID: M.UID, GID: M.GID,
340 Perms: M.Perms, Size);
341 if (isZOSArchive(Kind))
342 return printZOSMemberHeader(Out, Name: MemberName, ModTime, UID: M.UID, GID: M.GID, Perms: M.Perms,
343 Size);
344 if (!useStringTable(Thin, Name: MemberName))
345 return printGNUSmallMemberHeader(Out, Name: MemberName, ModTime, UID: M.UID, GID: M.GID,
346 Perms: M.Perms, Size);
347 Out << '/';
348 uint64_t NamePos;
349 if (Thin) {
350 NamePos = StringTable.tell();
351 StringTable << MemberName << "/\n";
352 } else {
353 auto Insertion = MemberNames.insert(KV: {MemberName, uint64_t(0)});
354 if (Insertion.second) {
355 Insertion.first->second = StringTable.tell();
356 StringTable << MemberName;
357 if (isCOFFArchive(Kind))
358 StringTable << '\0';
359 else
360 StringTable << "/\n";
361 }
362 NamePos = Insertion.first->second;
363 }
364 printWithSpacePadding(OS&: Out, Data: NamePos, Size: 15);
365 printRestOfMemberHeader(Out, ModTime, UID: M.UID, GID: M.GID, Perms: M.Perms, Size);
366}
367
368namespace {
369struct MemberData {
370 std::vector<unsigned> Symbols;
371 std::string Header;
372 StringRef Data;
373 StringRef Padding;
374 uint64_t PreHeadPadSize = 0;
375 std::unique_ptr<SymbolicFile> SymFile = nullptr;
376 std::string HybridName = "";
377 std::unique_ptr<MemoryBuffer> NativeBuf = nullptr;
378};
379} // namespace
380
381static MemberData computeStringTable(StringRef Names) {
382 unsigned Size = Names.size();
383 unsigned Pad = offsetToAlignment(Value: Size, Alignment: Align(2));
384 std::string Header;
385 raw_string_ostream Out(Header);
386 printWithSpacePadding(OS&: Out, Data: "//", Size: 48);
387 printWithSpacePadding(OS&: Out, Data: Size + Pad, Size: 10);
388 Out << "`\n";
389 return {.Symbols: {}, .Header: std::move(Header), .Data: Names, .Padding: Pad ? "\n" : ""};
390}
391
392static sys::TimePoint<std::chrono::seconds> now(bool Deterministic) {
393 using namespace std::chrono;
394
395 if (!Deterministic)
396 return time_point_cast<seconds>(t: system_clock::now());
397 return sys::TimePoint<seconds>();
398}
399
400static bool isArchiveSymbol(const object::BasicSymbolRef &S) {
401 Expected<uint32_t> SymFlagsOrErr = S.getFlags();
402 if (!SymFlagsOrErr)
403 // TODO: Actually report errors helpfully.
404 report_fatal_error(Err: SymFlagsOrErr.takeError());
405 if (*SymFlagsOrErr & object::SymbolRef::SF_FormatSpecific)
406 return false;
407 if (!(*SymFlagsOrErr & object::SymbolRef::SF_Global))
408 return false;
409 if (*SymFlagsOrErr & object::SymbolRef::SF_Undefined)
410 return false;
411 return true;
412}
413
414static void printNBits(raw_ostream &Out, object::Archive::Kind Kind,
415 uint64_t Val) {
416 if (is64BitKind(Kind))
417 print<uint64_t>(Out, Kind, Val);
418 else
419 print<uint32_t>(Out, Kind, Val);
420}
421
422static uint64_t computeSymbolTableSize(object::Archive::Kind Kind,
423 uint64_t NumSyms, uint64_t OffsetSize,
424 uint64_t StringTableSize,
425 uint32_t *Padding = nullptr) {
426 assert((OffsetSize == 4 || OffsetSize == 8) && "Unsupported OffsetSize");
427 uint64_t Size = OffsetSize; // Number of entries
428 // Each symbol table entry consists of a member offset.
429 // For BSD, each entry also includes a string table offset.
430 // For z/OS, each entry instead also includes a flag field.
431 if (isBSDLike(Kind) || isZOSArchive(Kind))
432 Size += NumSyms * OffsetSize * 2; // Table
433 else
434 Size += NumSyms * OffsetSize; // Table
435 if (isBSDLike(Kind))
436 Size += OffsetSize; // byte count
437 Size += StringTableSize;
438 // ld64 expects the members to be 8-byte aligned for 64-bit content and at
439 // least 4-byte aligned for 32-bit content. Opt for the larger encoding
440 // uniformly.
441 // We do this for all bsd formats because it simplifies aligning members.
442 // For the big archive format, the symbol table is the last member, so there
443 // is no need to align.
444 uint32_t Pad = isAIXBigArchive(Kind)
445 ? 0
446 : offsetToAlignment(Value: Size, Alignment: Align(isBSDLike(Kind) ? 8 : 2));
447
448 Size += Pad;
449 if (Padding)
450 *Padding = Pad;
451 return Size;
452}
453
454static uint64_t computeSymbolMapSize(uint64_t NumObj, SymMap &SymMap,
455 uint32_t *Padding = nullptr) {
456 uint64_t Size = sizeof(uint32_t) * 2; // Number of symbols and objects entries
457 Size += NumObj * sizeof(uint32_t); // Offset table
458
459 for (auto S : SymMap.Map)
460 Size += sizeof(uint16_t) + S.first.length() + 1;
461
462 uint32_t Pad = offsetToAlignment(Value: Size, Alignment: Align(2));
463 Size += Pad;
464 if (Padding)
465 *Padding = Pad;
466 return Size;
467}
468
469static uint64_t computeECSymbolsSize(SymMap &SymMap,
470 uint32_t *Padding = nullptr) {
471 uint64_t Size = sizeof(uint32_t); // Number of symbols
472
473 for (auto S : SymMap.ECMap)
474 Size += sizeof(uint16_t) + S.first.length() + 1;
475
476 uint32_t Pad = offsetToAlignment(Value: Size, Alignment: Align(2));
477 Size += Pad;
478 if (Padding)
479 *Padding = Pad;
480 return Size;
481}
482
483static void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind,
484 bool Deterministic, uint64_t Size,
485 uint64_t PrevMemberOffset = 0,
486 uint64_t NextMemberOffset = 0) {
487 if (isBSDLike(Kind)) {
488 const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF";
489 printBSDMemberHeader(Out, Pos: Out.tell(), Name, ModTime: now(Deterministic), UID: 0, GID: 0, Perms: 0,
490 Size);
491 } else if (isAIXBigArchive(Kind)) {
492 printBigArchiveMemberHeader(Out, Name: "", ModTime: now(Deterministic), UID: 0, GID: 0, Perms: 0, Size,
493 PrevOffset: PrevMemberOffset, NextOffset: NextMemberOffset);
494 } else if (isZOSArchive(Kind)) {
495 const char *Name = "__.SYMDEF";
496 printZOSMemberHeader(Out, Name, ModTime: now(Deterministic), UID: 0, GID: 0, Perms: 0, Size);
497 } else {
498 const char *Name = is64BitKind(Kind) ? "/SYM64" : "";
499 printGNUSmallMemberHeader(Out, Name, ModTime: now(Deterministic), UID: 0, GID: 0, Perms: 0, Size);
500 }
501}
502
503static uint64_t computeHeadersSize(object::Archive::Kind Kind,
504 uint64_t NumMembers,
505 uint64_t StringMemberSize, uint64_t NumSyms,
506 uint64_t SymNamesSize, SymMap *SymMap) {
507 uint32_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
508 uint64_t SymtabSize =
509 computeSymbolTableSize(Kind, NumSyms, OffsetSize, StringTableSize: SymNamesSize);
510 auto computeSymbolTableHeaderSize = [=] {
511 SmallString<0> TmpBuf;
512 raw_svector_ostream Tmp(TmpBuf);
513 writeSymbolTableHeader(Out&: Tmp, Kind, Deterministic: true, Size: SymtabSize);
514 return TmpBuf.size();
515 };
516 uint32_t HeaderSize = computeSymbolTableHeaderSize();
517 uint64_t Size = strlen(s: "!<arch>\n") + HeaderSize + SymtabSize;
518
519 if (SymMap) {
520 Size += HeaderSize + computeSymbolMapSize(NumObj: NumMembers, SymMap&: *SymMap);
521 if (SymMap->ECMap.size())
522 Size += HeaderSize + computeECSymbolsSize(SymMap&: *SymMap);
523 }
524
525 return Size + StringMemberSize;
526}
527
528static Expected<std::unique_ptr<SymbolicFile>>
529getSymbolicFile(MemoryBufferRef Buf, LLVMContext &Context,
530 object::Archive::Kind Kind, function_ref<void(Error)> Warn) {
531 const file_magic Type = identify_magic(magic: Buf.getBuffer());
532 // Don't attempt to read non-symbolic file types.
533 if (!object::SymbolicFile::isSymbolicFile(Type, Context: &Context))
534 return nullptr;
535 if (Type == file_magic::bitcode) {
536 auto ObjOrErr = object::SymbolicFile::createSymbolicFile(
537 Object: Buf, Type: file_magic::bitcode, Context: &Context);
538 // An error reading a bitcode file most likely indicates that the file
539 // was created by a compiler from the future. Normally we don't try to
540 // implement forwards compatibility for bitcode files, but when creating an
541 // archive we can implement best-effort forwards compatibility by treating
542 // the file as a blob and not creating symbol index entries for it. lld and
543 // mold ignore the archive symbol index, so provided that you use one of
544 // these linkers, LTO will work as long as lld or the gold plugin is newer
545 // than the compiler. We only ignore errors if the archive format is one
546 // that is supported by a linker that is known to ignore the index,
547 // otherwise there's no chance of this working so we may as well error out.
548 // We print a warning on read failure so that users of linkers that rely on
549 // the symbol index can diagnose the issue.
550 //
551 // This is the same behavior as GNU ar when the linker plugin returns an
552 // error when reading the input file. If the bitcode file is actually
553 // malformed, it will be diagnosed at link time.
554 if (!ObjOrErr) {
555 switch (Kind) {
556 case object::Archive::K_BSD:
557 case object::Archive::K_GNU:
558 case object::Archive::K_GNU64:
559 Warn(ObjOrErr.takeError());
560 return nullptr;
561 case object::Archive::K_AIXBIG:
562 case object::Archive::K_COFF:
563 case object::Archive::K_DARWIN:
564 case object::Archive::K_DARWIN64:
565 case object::Archive::K_ZOS:
566 return ObjOrErr.takeError();
567 }
568 }
569 return std::move(*ObjOrErr);
570 } else {
571 auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Object: Buf);
572 if (!ObjOrErr)
573 return ObjOrErr.takeError();
574 return std::move(*ObjOrErr);
575 }
576}
577
578static bool is64BitSymbolicFile(const SymbolicFile *SymObj) {
579 return SymObj != nullptr ? SymObj->is64Bit() : false;
580}
581
582// Log2 of PAGESIZE(4096) on an AIX system.
583static const uint32_t Log2OfAIXPageSize = 12;
584
585// In the AIX big archive format, since the data content follows the member file
586// name, if the name ends on an odd byte, an extra byte will be added for
587// padding. This ensures that the data within the member file starts at an even
588// byte.
589static const uint32_t MinBigArchiveMemDataAlign = 2;
590
591template <typename AuxiliaryHeader>
592uint16_t getAuxMaxAlignment(uint16_t AuxHeaderSize, AuxiliaryHeader *AuxHeader,
593 uint16_t Log2OfMaxAlign) {
594 // If the member doesn't have an auxiliary header, it isn't a loadable object
595 // and so it just needs aligning at the minimum value.
596 if (AuxHeader == nullptr)
597 return MinBigArchiveMemDataAlign;
598
599 // If the auxiliary header does not have both MaxAlignOfData and
600 // MaxAlignOfText field, it is not a loadable shared object file, so align at
601 // the minimum value. The 'ModuleType' member is located right after
602 // 'MaxAlignOfData' in the AuxiliaryHeader.
603 if (AuxHeaderSize < offsetof(AuxiliaryHeader, ModuleType))
604 return MinBigArchiveMemDataAlign;
605
606 // If the XCOFF object file does not have a loader section, it is not
607 // loadable, so align at the minimum value.
608 if (AuxHeader->SecNumOfLoader == 0)
609 return MinBigArchiveMemDataAlign;
610
611 // The content of the loadable member file needs to be aligned at MAX(maximum
612 // alignment of .text, maximum alignment of .data) if there are both fields.
613 // If the desired alignment is > PAGESIZE, 32-bit members are aligned on a
614 // word boundary, while 64-bit members are aligned on a PAGESIZE(2^12=4096)
615 // boundary.
616 uint16_t Log2OfAlign =
617 std::max(AuxHeader->MaxAlignOfText, AuxHeader->MaxAlignOfData);
618 return 1 << (Log2OfAlign > Log2OfAIXPageSize ? Log2OfMaxAlign : Log2OfAlign);
619}
620
621// AIX big archives may contain shared object members. The AIX OS requires these
622// members to be aligned if they are 64-bit and recommends it for 32-bit
623// members. This ensures that when these members are loaded they are aligned in
624// memory.
625static uint32_t getMemberAlignment(SymbolicFile *SymObj) {
626 XCOFFObjectFile *XCOFFObj = dyn_cast_or_null<XCOFFObjectFile>(Val: SymObj);
627 if (!XCOFFObj)
628 return MinBigArchiveMemDataAlign;
629
630 // If the desired alignment is > PAGESIZE, 32-bit members are aligned on a
631 // word boundary, while 64-bit members are aligned on a PAGESIZE boundary.
632 return XCOFFObj->is64Bit()
633 ? getAuxMaxAlignment(AuxHeaderSize: XCOFFObj->fileHeader64()->AuxHeaderSize,
634 AuxHeader: XCOFFObj->auxiliaryHeader64(),
635 Log2OfMaxAlign: Log2OfAIXPageSize)
636 : getAuxMaxAlignment(AuxHeaderSize: XCOFFObj->fileHeader32()->AuxHeaderSize,
637 AuxHeader: XCOFFObj->auxiliaryHeader32(), Log2OfMaxAlign: 2);
638}
639
640static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
641 bool Deterministic, ArrayRef<MemberData> Members,
642 StringRef StringTable, uint64_t MembersOffset,
643 unsigned NumSyms, uint64_t PrevMemberOffset = 0,
644 uint64_t NextMemberOffset = 0,
645 bool Is64Bit = false) {
646 // We don't write a symbol table on an archive with no members -- except on
647 // Darwin, where the linker will abort unless the archive has a symbol table.
648 if (StringTable.empty() && !isDarwin(Kind) && !isCOFFArchive(Kind))
649 return;
650
651 uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
652 uint32_t Pad;
653 uint64_t Size = computeSymbolTableSize(Kind, NumSyms, OffsetSize,
654 StringTableSize: StringTable.size(), Padding: &Pad);
655
656 // Padding size is not included in the Size field of the z/OS symbol table
657 // header.
658 int64_t HeaderSize = Size;
659 if (isZOSArchive(Kind))
660 HeaderSize -= Pad;
661
662 writeSymbolTableHeader(Out, Kind, Deterministic, Size: HeaderSize, PrevMemberOffset,
663 NextMemberOffset);
664
665 if (isBSDLike(Kind))
666 printNBits(Out, Kind, Val: NumSyms * 2 * OffsetSize);
667 else
668 printNBits(Out, Kind, Val: NumSyms);
669
670 uint64_t Pos = MembersOffset;
671 for (const MemberData &M : Members) {
672 if (isAIXBigArchive(Kind)) {
673 Pos += M.PreHeadPadSize;
674 if (is64BitSymbolicFile(SymObj: M.SymFile.get()) != Is64Bit) {
675 Pos += M.Header.size() + M.Data.size() + M.Padding.size();
676 continue;
677 }
678 }
679
680 for (unsigned StringOffset : M.Symbols) {
681 if (isBSDLike(Kind))
682 printNBits(Out, Kind, Val: StringOffset);
683 printNBits(Out, Kind, Val: Pos); // member offset
684 // FIXME: Properly handle symbol attributes for z/OS archives.
685 if (isZOSArchive(Kind))
686 printNBits(Out, Kind, Val: 0); // symbol flags
687 }
688 Pos += M.Header.size() + M.Data.size() + M.Padding.size();
689 }
690
691 if (isBSDLike(Kind))
692 // byte count of the string table
693 printNBits(Out, Kind, Val: StringTable.size());
694 if (isZOSArchive(Kind)) {
695 SmallString<256> EStringTable;
696 if (std::error_code EC =
697 ConverterEBCDIC::convertToEBCDIC(Source: StringTable, Result&: EStringTable))
698 report_fatal_error(
699 reason: Twine("failed to convert z/OS symbol table to EBCDIC: ") +
700 EC.message());
701 Out << EStringTable.str();
702 } else {
703 Out << StringTable;
704 }
705
706 while (Pad--)
707 Out.write(C: uint8_t(0));
708}
709
710static void writeSymbolMap(raw_ostream &Out, object::Archive::Kind Kind,
711 bool Deterministic, ArrayRef<MemberData> Members,
712 SymMap &SymMap, uint64_t MembersOffset) {
713 uint32_t Pad;
714 uint64_t Size = computeSymbolMapSize(NumObj: Members.size(), SymMap, Padding: &Pad);
715 writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset: 0);
716
717 uint32_t Pos = MembersOffset;
718
719 printLE<uint32_t>(Out, Val: Members.size());
720 for (const MemberData &M : Members) {
721 printLE(Out, Val: Pos); // member offset
722 Pos += M.Header.size() + M.Data.size() + M.Padding.size();
723 }
724
725 printLE<uint32_t>(Out, Val: SymMap.Map.size());
726
727 for (auto S : SymMap.Map)
728 printLE(Out, Val: S.second);
729 for (auto S : SymMap.Map)
730 Out << S.first << '\0';
731
732 while (Pad--)
733 Out.write(C: uint8_t(0));
734}
735
736static void writeECSymbols(raw_ostream &Out, object::Archive::Kind Kind,
737 bool Deterministic, ArrayRef<MemberData> Members,
738 SymMap &SymMap) {
739 uint32_t Pad;
740 uint64_t Size = computeECSymbolsSize(SymMap, Padding: &Pad);
741 printGNUSmallMemberHeader(Out, Name: "/<ECSYMBOLS>", ModTime: now(Deterministic), UID: 0, GID: 0, Perms: 0,
742 Size);
743
744 printLE<uint32_t>(Out, Val: SymMap.ECMap.size());
745
746 for (auto S : SymMap.ECMap)
747 printLE(Out, Val: S.second);
748 for (auto S : SymMap.ECMap)
749 Out << S.first << '\0';
750 while (Pad--)
751 Out.write(C: uint8_t(0));
752}
753
754static bool isECObject(object::SymbolicFile &Obj) {
755 if (Obj.isCOFF())
756 return cast<llvm::object::COFFObjectFile>(Val: &Obj)->getMachine() !=
757 COFF::IMAGE_FILE_MACHINE_ARM64;
758
759 if (Obj.isCOFFImportFile())
760 return cast<llvm::object::COFFImportFile>(Val: &Obj)->getMachine() !=
761 COFF::IMAGE_FILE_MACHINE_ARM64;
762
763 if (Obj.isIR()) {
764 Expected<std::string> TripleStr =
765 getBitcodeTargetTriple(Buffer: Obj.getMemoryBufferRef());
766 if (!TripleStr)
767 return false;
768 Triple T(std::move(*TripleStr));
769 return T.isWindowsArm64EC() || T.getArch() == Triple::x86_64;
770 }
771
772 return false;
773}
774
775static bool isAnyArm64COFF(object::SymbolicFile &Obj) {
776 if (Obj.isCOFF())
777 return COFF::isAnyArm64(Machine: cast<COFFObjectFile>(Val: &Obj)->getMachine());
778
779 if (Obj.isCOFFImportFile())
780 return COFF::isAnyArm64(Machine: cast<COFFImportFile>(Val: &Obj)->getMachine());
781
782 if (Obj.isIR()) {
783 Expected<std::string> TripleStr =
784 getBitcodeTargetTriple(Buffer: Obj.getMemoryBufferRef());
785 if (!TripleStr)
786 return false;
787 Triple T(std::move(*TripleStr));
788 return T.isOSWindows() && T.getArch() == Triple::aarch64;
789 }
790
791 return false;
792}
793
794bool isImportDescriptor(StringRef Name) {
795 return Name.starts_with(Prefix: ImportDescriptorPrefix) ||
796 Name == StringRef{NullImportDescriptorSymbolName} ||
797 (Name.starts_with(Prefix: NullThunkDataPrefix) &&
798 Name.ends_with(Suffix: NullThunkDataSuffix));
799}
800
801static Expected<std::vector<unsigned>> getSymbols(SymbolicFile *Obj,
802 uint16_t Index,
803 raw_ostream &SymNames,
804 SymMap *SymMap) {
805 std::vector<unsigned> Ret;
806
807 if (Obj == nullptr)
808 return Ret;
809
810 std::map<std::string, uint16_t> *Map = nullptr;
811 if (SymMap)
812 Map = SymMap->UseECMap && isECObject(Obj&: *Obj) ? &SymMap->ECMap : &SymMap->Map;
813
814 for (const object::BasicSymbolRef &S : Obj->symbols()) {
815 if (!isArchiveSymbol(S))
816 continue;
817 if (Map) {
818 std::string Name;
819 raw_string_ostream NameStream(Name);
820 if (Error E = S.printName(OS&: NameStream))
821 return std::move(E);
822 if (!Map->try_emplace(k: Name, args&: Index).second)
823 continue; // ignore duplicated symbol
824 if (Map == &SymMap->Map) {
825 Ret.push_back(x: SymNames.tell());
826 SymNames << Name << '\0';
827 // If EC is enabled, then the import descriptors are NOT put into EC
828 // objects so we need to copy them to the EC map manually.
829 if (SymMap->UseECMap && isImportDescriptor(Name))
830 SymMap->ECMap[Name] = Index;
831 }
832 } else {
833 Ret.push_back(x: SymNames.tell());
834 if (Error E = S.printName(OS&: SymNames))
835 return std::move(E);
836 SymNames << '\0';
837 }
838 }
839 return Ret;
840}
841
842static Expected<std::vector<MemberData>>
843computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames,
844 object::Archive::Kind Kind, bool Thin, bool Deterministic,
845 SymtabWritingMode NeedSymbols, SymMap *SymMap,
846 LLVMContext &Context, ArrayRef<NewArchiveMember> NewMembers,
847 std::optional<bool> IsEC, function_ref<void(Error)> Warn) {
848 static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'};
849 static char ZOSPaddingData[8] = {0x15, 0x15, 0x15, 0x15,
850 0x15, 0x15, 0x15, 0x15}; // EBCDIC newlines.
851 uint64_t Pos =
852 isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 0;
853
854 std::vector<MemberData> Ret;
855 bool HasObject = false;
856
857 // Deduplicate long member names in the string table and reuse earlier name
858 // offsets. This especially saves space for COFF Import libraries where all
859 // members have the same name.
860 StringMap<uint64_t> MemberNames;
861
862 // UniqueTimestamps is a special case to improve debugging on Darwin:
863 //
864 // The Darwin linker does not link debug info into the final
865 // binary. Instead, it emits entries of type N_OSO in the output
866 // binary's symbol table, containing references to the linked-in
867 // object files. Using that reference, the debugger can read the
868 // debug data directly from the object files. Alternatively, an
869 // invocation of 'dsymutil' will link the debug data from the object
870 // files into a dSYM bundle, which can be loaded by the debugger,
871 // instead of the object files.
872 //
873 // For an object file, the N_OSO entries contain the absolute path
874 // path to the file, and the file's timestamp. For an object
875 // included in an archive, the path is formatted like
876 // "/absolute/path/to/archive.a(member.o)", and the timestamp is the
877 // archive member's timestamp, rather than the archive's timestamp.
878 //
879 // However, this doesn't always uniquely identify an object within
880 // an archive -- an archive file can have multiple entries with the
881 // same filename. (This will happen commonly if the original object
882 // files started in different directories.) The only way they get
883 // distinguished, then, is via the timestamp. But this process is
884 // unable to find the correct object file in the archive when there
885 // are two files of the same name and timestamp.
886 //
887 // Additionally, timestamp==0 is treated specially, and causes the
888 // timestamp to be ignored as a match criteria.
889 //
890 // That will "usually" work out okay when creating an archive not in
891 // deterministic timestamp mode, because the objects will probably
892 // have been created at different timestamps.
893 //
894 // To ameliorate this problem, in deterministic archive mode (which
895 // is the default), on Darwin we will emit a unique non-zero
896 // timestamp for each entry with a duplicated name. This is still
897 // deterministic: the only thing affecting that timestamp is the
898 // order of the files in the resultant archive.
899 //
900 // See also the functions that handle the lookup:
901 // in lldb: ObjectContainerBSDArchive::Archive::FindObject()
902 // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers().
903 bool UniqueTimestamps = Deterministic && isDarwin(Kind);
904 std::map<StringRef, unsigned> FilenameCount;
905 if (UniqueTimestamps) {
906 for (const NewArchiveMember &M : NewMembers)
907 FilenameCount[M.MemberName]++;
908 for (auto &Entry : FilenameCount)
909 Entry.second = Entry.second > 1 ? 1 : 0;
910 }
911
912 uint32_t LastZosObjIndex =
913 UINT_MAX; // Only set when writing symbol table in z/OS archive.
914
915 for (const NewArchiveMember &M : NewMembers) {
916 MemberData &D = Ret.emplace_back();
917 D.Data = M.Buf->getBuffer();
918
919 if (NeedSymbols != SymtabWritingMode::NoSymtab || isAIXBigArchive(Kind)) {
920 Expected<std::unique_ptr<SymbolicFile>> SymFileOrErr = getSymbolicFile(
921 Buf: M.Buf->getMemBufferRef(), Context, Kind, Warn: [&](Error Err) {
922 Warn(createFileError(F: M.MemberName, E: std::move(Err)));
923 });
924 if (!SymFileOrErr)
925 return createFileError(F: M.MemberName, E: SymFileOrErr.takeError());
926 D.SymFile = std::move(*SymFileOrErr);
927
928 if (SymMap && D.SymFile.get()) {
929 auto COFFObj = dyn_cast<COFFObjectFile>(Val: D.SymFile.get());
930 std::optional<MemoryBufferRef> HybridView;
931 if (COFFObj && (HybridView = COFFObj->findHybridObjectSection())) {
932 // Strip the hybrid section.
933 D.NativeBuf = COFFObj->stripHybridSection();
934 D.Data = D.NativeBuf->getBuffer();
935
936 // Create a separate archive member for the hybrid ARM64X object.
937 MemberData &ECData = Ret.emplace_back();
938 ECData.Data = HybridView->getBuffer();
939
940 SymFileOrErr =
941 getSymbolicFile(Buf: *HybridView, Context, Kind, Warn: [&](Error Err) {
942 Warn(createFileError(F: M.MemberName, E: std::move(Err)));
943 });
944 if (!SymFileOrErr)
945 return createFileError(F: M.MemberName, E: SymFileOrErr.takeError());
946 ECData.SymFile = std::move(*SymFileOrErr);
947
948 // Use obj.arm64ec subdirectory for the hybrid object name.
949 size_t Pos = M.MemberName.find_last_of(Chars: "/\\");
950 Pos = Pos == StringRef::npos ? 0 : Pos + 1;
951 ECData.HybridName = (M.MemberName.substr(Start: 0, N: Pos) + "obj.arm64ec/" +
952 M.MemberName.substr(Start: Pos))
953 .str();
954 }
955 }
956
957 if (isZOSArchive(Kind) && D.SymFile.get())
958 LastZosObjIndex = Ret.size() - 1;
959 }
960 }
961
962 if (SymMap) {
963 if (IsEC) {
964 SymMap->UseECMap = *IsEC;
965 } else {
966 // When IsEC is not specified by the caller, use it when we have both
967 // any ARM64 object (ARM64 or ARM64EC) and any EC object (ARM64EC or
968 // AMD64). This may be a single ARM64EC object, but may also be separate
969 // ARM64 and AMD64 objects.
970 bool HaveArm64 = false, HaveEC = false;
971 for (const MemberData &D : Ret) {
972 if (!D.SymFile)
973 continue;
974 if (!HaveArm64)
975 HaveArm64 = isAnyArm64COFF(Obj&: *D.SymFile);
976 if (!HaveEC)
977 HaveEC = isECObject(Obj&: *D.SymFile);
978 if (HaveArm64 && HaveEC) {
979 SymMap->UseECMap = true;
980 break;
981 }
982 }
983 }
984 }
985
986 // The big archive format needs to know the offset of the previous member
987 // header.
988 uint64_t PrevOffset = 0;
989 uint64_t NextMemHeadPadSize = 0;
990
991 for (uint32_t Index = 0, MemberIndex = 0; Index < Ret.size(); ++Index) {
992 MemberData &D = Ret[Index];
993 const NewArchiveMember *M = &NewMembers[MemberIndex];
994 // Native COFF members (resulting from stripping a hybrid object section)
995 // are followed by an extracted hybrid object member, using the same
996 // NewArchiveMember.
997 if (!D.NativeBuf.get())
998 ++MemberIndex;
999 raw_string_ostream Out(D.Header);
1000
1001 uint64_t Size = D.Data.size();
1002 if (Thin)
1003 D.Data = "";
1004
1005 // ld64 expects the members to be 8-byte aligned for 64-bit content and at
1006 // least 4-byte aligned for 32-bit content. Opt for the larger encoding
1007 // uniformly. This matches the behaviour with cctools and ensures that ld64
1008 // is happy with archives that we generate.
1009 unsigned MemberPadding =
1010 isDarwin(Kind) ? offsetToAlignment(Value: D.Data.size(), Alignment: Align(8)) : 0;
1011
1012 StringRef MemberName = D.HybridName.size() ? D.HybridName : M->MemberName;
1013
1014 // z/OS stores long member names inline using their exact byte length.
1015 // Include the inline name when computing alignment.
1016 uint64_t PaddingBase = D.Data.size() + MemberPadding;
1017 if (isZOSArchive(Kind) && MemberName.size() > 16)
1018 PaddingBase += MemberName.size();
1019 unsigned TailPadding = offsetToAlignment(Value: PaddingBase, Alignment: Align(2));
1020 D.Padding = StringRef(isZOSArchive(Kind) ? ZOSPaddingData : PaddingData,
1021 MemberPadding + TailPadding);
1022
1023 sys::TimePoint<std::chrono::seconds> ModTime;
1024 if (UniqueTimestamps)
1025 // Increment timestamp for each file of a given name.
1026 ModTime = sys::toTimePoint(T: FilenameCount[MemberName]++);
1027 else
1028 ModTime = M->ModTime;
1029
1030 Size += MemberPadding;
1031 if (Size > object::Archive::MaxMemberSize) {
1032 std::string StringMsg =
1033 "File " + MemberName.str() + " exceeds size limit";
1034 return make_error<object::GenericBinaryError>(
1035 Args: std::move(StringMsg), Args: object::object_error::parse_failed);
1036 }
1037
1038 // In the big archive file format, we need to calculate and include the next
1039 // member offset and previous member offset in the file member header.
1040 if (isAIXBigArchive(Kind)) {
1041 uint64_t OffsetToMemData =
1042 Pos + sizeof(object::BigArMemHdrType) + alignTo(Value: MemberName.size(), Align: 2);
1043
1044 if (Index == 0)
1045 NextMemHeadPadSize =
1046 alignToPowerOf2(Value: OffsetToMemData,
1047 Align: getMemberAlignment(SymObj: D.SymFile.get())) -
1048 OffsetToMemData;
1049
1050 D.PreHeadPadSize = NextMemHeadPadSize;
1051 Pos += D.PreHeadPadSize;
1052 uint64_t NextOffset = Pos + sizeof(object::BigArMemHdrType) +
1053 alignTo(Value: MemberName.size(), Align: 2) + alignTo(Value: Size, Align: 2);
1054
1055 // If there is another member file after this, we need to calculate the
1056 // padding before the header.
1057 if (Index + 1 != Ret.size()) {
1058 uint64_t OffsetToNextMemData =
1059 NextOffset + sizeof(object::BigArMemHdrType) +
1060 alignTo(Value: NewMembers[MemberIndex].MemberName.size(), Align: 2);
1061 NextMemHeadPadSize =
1062 alignToPowerOf2(Value: OffsetToNextMemData,
1063 Align: getMemberAlignment(SymObj: Ret[Index + 1].SymFile.get())) -
1064 OffsetToNextMemData;
1065 NextOffset += NextMemHeadPadSize;
1066 }
1067 printBigArchiveMemberHeader(Out, Name: MemberName, ModTime, UID: M->UID, GID: M->GID,
1068 Perms: M->Perms, Size, PrevOffset, NextOffset);
1069 PrevOffset = Pos;
1070 } else {
1071 printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M: *M,
1072 MemberName, ModTime, Size);
1073 }
1074
1075 if (NeedSymbols != SymtabWritingMode::NoSymtab) {
1076 Expected<std::vector<unsigned>> SymbolsOrErr =
1077 getSymbols(Obj: D.SymFile.get(), Index: Index + 1, SymNames, SymMap);
1078 if (!SymbolsOrErr)
1079 return createFileError(F: MemberName, E: SymbolsOrErr.takeError());
1080 D.Symbols = std::move(*SymbolsOrErr);
1081 if (D.SymFile)
1082 HasObject = true;
1083 }
1084 // On z/OS, when there are no symbols, add a dummy blank symbol
1085 // into the symbol table. This is done since the z/OS binder:
1086 // - emits an error if there is no symbol table in the archive
1087 // - emits an error if the symbol table has 0 symbols
1088 // - should not find any references to a blank symbol
1089 if ((LastZosObjIndex == Index) && (SymNames.tell() == 0)) {
1090 D.Symbols.push_back(x: 0);
1091 SymNames << ' ' << '\0';
1092 }
1093
1094 Pos += D.Header.size() + D.Data.size() + D.Padding.size();
1095 }
1096 // If there are no symbols, emit an empty symbol table, to satisfy Solaris
1097 // tools, older versions of which expect a symbol table in a non-empty
1098 // archive, regardless of whether there are any symbols in it.
1099 if (HasObject && SymNames.tell() == 0 && !isCOFFArchive(Kind))
1100 SymNames << '\0' << '\0' << '\0';
1101 return std::move(Ret);
1102}
1103
1104namespace llvm {
1105
1106static ErrorOr<SmallString<128>> canonicalizePath(StringRef P) {
1107 SmallString<128> Ret = P;
1108 std::error_code Err = sys::fs::make_absolute(path&: Ret);
1109 if (Err)
1110 return Err;
1111 sys::path::remove_dots(path&: Ret, /*removedotdot*/ remove_dot_dot: true);
1112 return Ret;
1113}
1114
1115// Compute the relative path from From to To.
1116Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To) {
1117 ErrorOr<SmallString<128>> PathToOrErr = canonicalizePath(P: To);
1118 ErrorOr<SmallString<128>> DirFromOrErr = canonicalizePath(P: From);
1119 if (!PathToOrErr || !DirFromOrErr)
1120 return errorCodeToError(EC: errnoAsErrorCode());
1121
1122 const SmallString<128> &PathTo = *PathToOrErr;
1123 const SmallString<128> &DirFrom = sys::path::parent_path(path: *DirFromOrErr);
1124
1125 // Can't construct a relative path between different roots
1126 if (sys::path::root_name(path: PathTo) != sys::path::root_name(path: DirFrom))
1127 return sys::path::convert_to_slash(path: PathTo);
1128
1129 // Skip common prefixes
1130 auto FromTo =
1131 std::mismatch(first1: sys::path::begin(path: DirFrom), last1: sys::path::end(path: DirFrom),
1132 first2: sys::path::begin(path: PathTo));
1133 auto FromI = FromTo.first;
1134 auto ToI = FromTo.second;
1135
1136 // Construct relative path
1137 SmallString<128> Relative;
1138 for (auto FromE = sys::path::end(path: DirFrom); FromI != FromE; ++FromI)
1139 sys::path::append(path&: Relative, style: sys::path::Style::posix, a: "..");
1140
1141 for (auto ToE = sys::path::end(path: PathTo); ToI != ToE; ++ToI)
1142 sys::path::append(path&: Relative, style: sys::path::Style::posix, a: *ToI);
1143
1144 return std::string(Relative);
1145}
1146
1147Error writeArchiveToStream(raw_ostream &Out,
1148 ArrayRef<NewArchiveMember> NewMembers,
1149 SymtabWritingMode WriteSymtab,
1150 object::Archive::Kind Kind, bool Deterministic,
1151 bool Thin, std::optional<bool> IsEC,
1152 function_ref<void(Error)> Warn) {
1153 assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode");
1154
1155 SmallString<0> SymNamesBuf;
1156 raw_svector_ostream SymNames(SymNamesBuf);
1157 SmallString<0> StringTableBuf;
1158 raw_svector_ostream StringTable(StringTableBuf);
1159 SymMap SymMap;
1160 bool ShouldWriteSymtab = WriteSymtab != SymtabWritingMode::NoSymtab;
1161
1162 // COFF symbol map uses 16-bit indexes, so we can't use it if there are too
1163 // many members. COFF format also requires symbol table presence, so use
1164 // GNU format when NoSymtab is requested.
1165 if (isCOFFArchive(Kind) && (NewMembers.size() > 0xfffe || !ShouldWriteSymtab))
1166 Kind = object::Archive::K_GNU;
1167
1168 // In the scenario when LLVMContext is populated SymbolicFile will contain a
1169 // reference to it, thus SymbolicFile should be destroyed first.
1170 LLVMContext Context;
1171
1172 Expected<std::vector<MemberData>> DataOrErr = computeMemberData(
1173 StringTable, SymNames, Kind, Thin, Deterministic, NeedSymbols: WriteSymtab,
1174 SymMap: isCOFFArchive(Kind) ? &SymMap : nullptr, Context, NewMembers, IsEC, Warn);
1175 if (Error E = DataOrErr.takeError())
1176 return E;
1177 std::vector<MemberData> &Data = *DataOrErr;
1178
1179 uint64_t StringTableSize = 0;
1180 MemberData StringTableMember;
1181 if (!StringTableBuf.empty() && !isAIXBigArchive(Kind)) {
1182 StringTableMember = computeStringTable(Names: StringTableBuf);
1183 StringTableSize = StringTableMember.Header.size() +
1184 StringTableMember.Data.size() +
1185 StringTableMember.Padding.size();
1186 }
1187
1188 // We would like to detect if we need to switch to a 64-bit symbol table.
1189 uint64_t LastMemberEndOffset = 0;
1190 uint64_t LastMemberHeaderOffset = 0;
1191 uint64_t NumSyms = 0;
1192 uint64_t NumSyms32 = 0; // Store symbol number of 32-bit member files.
1193
1194 for (const auto &M : Data) {
1195 // Record the start of the member's offset
1196 LastMemberEndOffset += M.PreHeadPadSize;
1197 LastMemberHeaderOffset = LastMemberEndOffset;
1198 // Account for the size of each part associated with the member.
1199 LastMemberEndOffset += M.Header.size() + M.Data.size() + M.Padding.size();
1200 NumSyms += M.Symbols.size();
1201
1202 // AIX big archive files may contain two global symbol tables. The
1203 // first global symbol table locates 32-bit file members that define global
1204 // symbols; the second global symbol table does the same for 64-bit file
1205 // members. As a big archive can have both 32-bit and 64-bit file members,
1206 // we need to know the number of symbols in each symbol table individually.
1207 if (isAIXBigArchive(Kind) && ShouldWriteSymtab) {
1208 if (!is64BitSymbolicFile(SymObj: M.SymFile.get()))
1209 NumSyms32 += M.Symbols.size();
1210 }
1211 }
1212
1213 std::optional<uint64_t> HeadersSize;
1214
1215 // The symbol table is put at the end of the big archive file. The symbol
1216 // table is at the start of the archive file for other archive formats.
1217 if (ShouldWriteSymtab && !is64BitKind(Kind)) {
1218 // We assume 32-bit offsets to see if 32-bit symbols are possible or not.
1219 HeadersSize = computeHeadersSize(Kind, NumMembers: Data.size(), StringMemberSize: StringTableSize,
1220 NumSyms, SymNamesSize: SymNamesBuf.size(),
1221 SymMap: isCOFFArchive(Kind) ? &SymMap : nullptr);
1222
1223 // The SYM64 format is used when an archive's member offsets are larger than
1224 // 32-bits can hold. The need for this shift in format is detected by
1225 // writeArchive. To test this we need to generate a file with a member that
1226 // has an offset larger than 32-bits but this demands a very slow test. To
1227 // speed the test up we use this environment variable to pretend like the
1228 // cutoff happens before 32-bits and instead happens at some much smaller
1229 // value.
1230 uint64_t Sym64Threshold = 1ULL << 32;
1231 const char *Sym64Env = std::getenv(name: "SYM64_THRESHOLD");
1232 if (Sym64Env)
1233 StringRef(Sym64Env).getAsInteger(Radix: 10, Result&: Sym64Threshold);
1234
1235 // If LastMemberHeaderOffset isn't going to fit in a 32-bit varible we need
1236 // to switch to 64-bit. Note that the file can be larger than 4GB as long as
1237 // the last member starts before the 4GB offset.
1238 if (*HeadersSize + LastMemberHeaderOffset >= Sym64Threshold) {
1239 switch (Kind) {
1240 case object::Archive::K_COFF:
1241 // COFF format has no 64-bit version, so we use GNU64 instead.
1242 if (!SymMap.Map.empty() && !SymMap.ECMap.empty())
1243 // Only the COFF format supports the ECSYMBOLS section, so don’t use
1244 // GNU64 when two symbol maps are required.
1245 return make_error<object::GenericBinaryError>(
1246 Args: "Archive is too large: ARM64X does not support archives larger "
1247 "than 4GB");
1248 // Since this changes the headers, we need to recalculate everything.
1249 return writeArchiveToStream(Out, NewMembers, WriteSymtab,
1250 Kind: object::Archive::K_GNU64, Deterministic,
1251 Thin, IsEC, Warn);
1252 case object::Archive::K_DARWIN:
1253 Kind = object::Archive::K_DARWIN64;
1254 break;
1255 default:
1256 Kind = object::Archive::K_GNU64;
1257 break;
1258 }
1259 HeadersSize.reset();
1260 }
1261 }
1262
1263 if (Thin)
1264 Out << "!<thin>\n";
1265 else if (isAIXBigArchive(Kind))
1266 Out << "<bigaf>\n";
1267 else if (isZOSArchive(Kind))
1268 Out << ZOSArchiveMagic;
1269 else
1270 Out << "!<arch>\n";
1271
1272 if (!isAIXBigArchive(Kind)) {
1273 if (ShouldWriteSymtab) {
1274 if (!HeadersSize)
1275 HeadersSize = computeHeadersSize(
1276 Kind, NumMembers: Data.size(), StringMemberSize: StringTableSize, NumSyms, SymNamesSize: SymNamesBuf.size(),
1277 SymMap: isCOFFArchive(Kind) ? &SymMap : nullptr);
1278 writeSymbolTable(Out, Kind, Deterministic, Members: Data, StringTable: SymNamesBuf,
1279 MembersOffset: *HeadersSize, NumSyms);
1280
1281 if (isCOFFArchive(Kind))
1282 writeSymbolMap(Out, Kind, Deterministic, Members: Data, SymMap, MembersOffset: *HeadersSize);
1283 }
1284
1285 if (StringTableSize)
1286 Out << StringTableMember.Header << StringTableMember.Data
1287 << StringTableMember.Padding;
1288
1289 if (ShouldWriteSymtab && SymMap.ECMap.size())
1290 writeECSymbols(Out, Kind, Deterministic, Members: Data, SymMap);
1291
1292 for (const MemberData &M : Data)
1293 Out << M.Header << M.Data << M.Padding;
1294 } else {
1295 HeadersSize = sizeof(object::BigArchive::FixLenHdr);
1296 LastMemberEndOffset += *HeadersSize;
1297 LastMemberHeaderOffset += *HeadersSize;
1298
1299 // For the big archive (AIX) format, compute a table of member names and
1300 // offsets, used in the member table.
1301 uint64_t MemberTableNameStrTblSize = 0;
1302 std::vector<size_t> MemberOffsets;
1303 std::vector<StringRef> MemberNames;
1304 // Loop across object to find offset and names.
1305 uint64_t MemberEndOffset = sizeof(object::BigArchive::FixLenHdr);
1306 for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) {
1307 const NewArchiveMember &Member = NewMembers[I];
1308 MemberTableNameStrTblSize += Member.MemberName.size() + 1;
1309 MemberEndOffset += Data[I].PreHeadPadSize;
1310 MemberOffsets.push_back(x: MemberEndOffset);
1311 MemberNames.push_back(x: Member.MemberName);
1312 // File member name ended with "`\n". The length is included in
1313 // BigArMemHdrType.
1314 MemberEndOffset += sizeof(object::BigArMemHdrType) +
1315 alignTo(Value: Data[I].Data.size(), Align: 2) +
1316 alignTo(Value: Member.MemberName.size(), Align: 2);
1317 }
1318
1319 // AIX member table size.
1320 uint64_t MemberTableSize = 20 + // Number of members field
1321 20 * MemberOffsets.size() +
1322 MemberTableNameStrTblSize;
1323
1324 SmallString<0> SymNamesBuf32;
1325 SmallString<0> SymNamesBuf64;
1326 raw_svector_ostream SymNames32(SymNamesBuf32);
1327 raw_svector_ostream SymNames64(SymNamesBuf64);
1328
1329 if (ShouldWriteSymtab && NumSyms)
1330 // Generate the symbol names for the members.
1331 for (const auto &M : Data) {
1332 Expected<std::vector<unsigned>> SymbolsOrErr = getSymbols(
1333 Obj: M.SymFile.get(), Index: 0,
1334 SymNames&: is64BitSymbolicFile(SymObj: M.SymFile.get()) ? SymNames64 : SymNames32,
1335 SymMap: nullptr);
1336 if (!SymbolsOrErr)
1337 return SymbolsOrErr.takeError();
1338 }
1339
1340 uint64_t MemberTableEndOffset =
1341 LastMemberEndOffset +
1342 alignTo(Value: sizeof(object::BigArMemHdrType) + MemberTableSize, Align: 2);
1343
1344 // In AIX OS, The 'GlobSymOffset' field in the fixed-length header contains
1345 // the offset to the 32-bit global symbol table, and the 'GlobSym64Offset'
1346 // contains the offset to the 64-bit global symbol table.
1347 uint64_t GlobalSymbolOffset =
1348 (ShouldWriteSymtab &&
1349 (WriteSymtab != SymtabWritingMode::BigArchive64) && NumSyms32 > 0)
1350 ? MemberTableEndOffset
1351 : 0;
1352
1353 uint64_t GlobalSymbolOffset64 = 0;
1354 uint64_t NumSyms64 = NumSyms - NumSyms32;
1355 if (ShouldWriteSymtab && (WriteSymtab != SymtabWritingMode::BigArchive32) &&
1356 NumSyms64 > 0) {
1357 if (GlobalSymbolOffset == 0)
1358 GlobalSymbolOffset64 = MemberTableEndOffset;
1359 else
1360 // If there is a global symbol table for 32-bit members,
1361 // the 64-bit global symbol table is after the 32-bit one.
1362 GlobalSymbolOffset64 =
1363 GlobalSymbolOffset + sizeof(object::BigArMemHdrType) +
1364 (NumSyms32 + 1) * 8 + alignTo(Value: SymNamesBuf32.size(), Align: 2);
1365 }
1366
1367 // Fixed Sized Header.
1368 printWithSpacePadding(OS&: Out, Data: NewMembers.size() ? LastMemberEndOffset : 0,
1369 Size: 20); // Offset to member table
1370 // If there are no file members in the archive, there will be no global
1371 // symbol table.
1372 printWithSpacePadding(OS&: Out, Data: GlobalSymbolOffset, Size: 20);
1373 printWithSpacePadding(OS&: Out, Data: GlobalSymbolOffset64, Size: 20);
1374 printWithSpacePadding(OS&: Out,
1375 Data: NewMembers.size()
1376 ? sizeof(object::BigArchive::FixLenHdr) +
1377 Data[0].PreHeadPadSize
1378 : 0,
1379 Size: 20); // Offset to first archive member
1380 printWithSpacePadding(OS&: Out, Data: NewMembers.size() ? LastMemberHeaderOffset : 0,
1381 Size: 20); // Offset to last archive member
1382 printWithSpacePadding(
1383 OS&: Out, Data: 0,
1384 Size: 20); // Offset to first member of free list - Not supported yet
1385
1386 for (const MemberData &M : Data) {
1387 Out << std::string(M.PreHeadPadSize, '\0');
1388 Out << M.Header << M.Data;
1389 if (M.Data.size() % 2)
1390 Out << '\0';
1391 }
1392
1393 if (NewMembers.size()) {
1394 // Member table.
1395 printBigArchiveMemberHeader(Out, Name: "", ModTime: sys::toTimePoint(T: 0), UID: 0, GID: 0, Perms: 0,
1396 Size: MemberTableSize, PrevOffset: LastMemberHeaderOffset,
1397 NextOffset: GlobalSymbolOffset ? GlobalSymbolOffset
1398 : GlobalSymbolOffset64);
1399 printWithSpacePadding(OS&: Out, Data: MemberOffsets.size(), Size: 20); // Number of members
1400 for (uint64_t MemberOffset : MemberOffsets)
1401 printWithSpacePadding(OS&: Out, Data: MemberOffset,
1402 Size: 20); // Offset to member file header.
1403 for (StringRef MemberName : MemberNames)
1404 Out << MemberName << '\0'; // Member file name, null byte padding.
1405
1406 if (MemberTableNameStrTblSize % 2)
1407 Out << '\0'; // Name table must be tail padded to an even number of
1408 // bytes.
1409
1410 if (ShouldWriteSymtab) {
1411 // Write global symbol table for 32-bit file members.
1412 if (GlobalSymbolOffset) {
1413 writeSymbolTable(Out, Kind, Deterministic, Members: Data, StringTable: SymNamesBuf32,
1414 MembersOffset: *HeadersSize, NumSyms: NumSyms32, PrevMemberOffset: LastMemberEndOffset,
1415 NextMemberOffset: GlobalSymbolOffset64);
1416 // Add padding between the symbol tables, if needed.
1417 if (GlobalSymbolOffset64 && (SymNamesBuf32.size() % 2))
1418 Out << '\0';
1419 }
1420
1421 // Write global symbol table for 64-bit file members.
1422 if (GlobalSymbolOffset64)
1423 writeSymbolTable(Out, Kind, Deterministic, Members: Data, StringTable: SymNamesBuf64,
1424 MembersOffset: *HeadersSize, NumSyms: NumSyms64,
1425 PrevMemberOffset: GlobalSymbolOffset ? GlobalSymbolOffset
1426 : LastMemberEndOffset,
1427 NextMemberOffset: 0, Is64Bit: true);
1428 }
1429 }
1430 }
1431 Out.flush();
1432 return Error::success();
1433}
1434
1435void warnToStderr(Error Err) {
1436 llvm::logAllUnhandledErrors(E: std::move(Err), OS&: llvm::errs(), ErrorBanner: "warning: ");
1437}
1438
1439Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers,
1440 SymtabWritingMode WriteSymtab, object::Archive::Kind Kind,
1441 bool Deterministic, bool Thin,
1442 std::unique_ptr<MemoryBuffer> OldArchiveBuf,
1443 std::optional<bool> IsEC, function_ref<void(Error)> Warn) {
1444 Expected<sys::fs::TempFile> Temp =
1445 sys::fs::TempFile::create(Model: ArcName + ".temp-archive-%%%%%%%.a");
1446 if (!Temp)
1447 return Temp.takeError();
1448 raw_fd_ostream Out(Temp->FD, false);
1449
1450 if (Error E = writeArchiveToStream(Out, NewMembers, WriteSymtab, Kind,
1451 Deterministic, Thin, IsEC, Warn)) {
1452 if (Error DiscardError = Temp->discard())
1453 return joinErrors(E1: std::move(E), E2: std::move(DiscardError));
1454 return E;
1455 }
1456
1457 // At this point, we no longer need whatever backing memory
1458 // was used to generate the NewMembers. On Windows, this buffer
1459 // could be a mapped view of the file we want to replace (if
1460 // we're updating an existing archive, say). In that case, the
1461 // rename would still succeed, but it would leave behind a
1462 // temporary file (actually the original file renamed) because
1463 // a file cannot be deleted while there's a handle open on it,
1464 // only renamed. So by freeing this buffer, this ensures that
1465 // the last open handle on the destination file, if any, is
1466 // closed before we attempt to rename.
1467 OldArchiveBuf.reset();
1468
1469 return Temp->keep(Name: ArcName);
1470}
1471
1472Expected<std::unique_ptr<MemoryBuffer>>
1473writeArchiveToBuffer(ArrayRef<NewArchiveMember> NewMembers,
1474 SymtabWritingMode WriteSymtab, object::Archive::Kind Kind,
1475 bool Deterministic, bool Thin,
1476 function_ref<void(Error)> Warn) {
1477 SmallVector<char, 0> ArchiveBufferVector;
1478 raw_svector_ostream ArchiveStream(ArchiveBufferVector);
1479
1480 if (Error E =
1481 writeArchiveToStream(Out&: ArchiveStream, NewMembers, WriteSymtab, Kind,
1482 Deterministic, Thin, IsEC: std::nullopt, Warn))
1483 return std::move(E);
1484
1485 return std::make_unique<SmallVectorMemoryBuffer>(
1486 args: std::move(ArchiveBufferVector), /*RequiresNullTerminator=*/args: false);
1487}
1488
1489} // namespace llvm
1490