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/Error.h" 21 #include "llvm/Object/ObjectFile.h" 22 #include "llvm/Object/SymbolicFile.h" 23 #include "llvm/Support/Alignment.h" 24 #include "llvm/Support/EndianStream.h" 25 #include "llvm/Support/Errc.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/Format.h" 28 #include "llvm/Support/Path.h" 29 #include "llvm/Support/SmallVectorMemoryBuffer.h" 30 #include "llvm/Support/ToolOutputFile.h" 31 #include "llvm/Support/raw_ostream.h" 32 33 #include <map> 34 35 #if !defined(_MSC_VER) && !defined(__MINGW32__) 36 #include <unistd.h> 37 #else 38 #include <io.h> 39 #endif 40 41 using namespace llvm; 42 43 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef) 44 : Buf(MemoryBuffer::getMemBuffer(BufRef, false)), 45 MemberName(BufRef.getBufferIdentifier()) {} 46 47 Expected<NewArchiveMember> 48 NewArchiveMember::getOldMember(const object::Archive::Child &OldMember, 49 bool Deterministic) { 50 Expected<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef(); 51 if (!BufOrErr) 52 return BufOrErr.takeError(); 53 54 NewArchiveMember M; 55 M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false); 56 M.MemberName = M.Buf->getBufferIdentifier(); 57 if (!Deterministic) { 58 auto ModTimeOrErr = OldMember.getLastModified(); 59 if (!ModTimeOrErr) 60 return ModTimeOrErr.takeError(); 61 M.ModTime = ModTimeOrErr.get(); 62 Expected<unsigned> UIDOrErr = OldMember.getUID(); 63 if (!UIDOrErr) 64 return UIDOrErr.takeError(); 65 M.UID = UIDOrErr.get(); 66 Expected<unsigned> GIDOrErr = OldMember.getGID(); 67 if (!GIDOrErr) 68 return GIDOrErr.takeError(); 69 M.GID = GIDOrErr.get(); 70 Expected<sys::fs::perms> AccessModeOrErr = OldMember.getAccessMode(); 71 if (!AccessModeOrErr) 72 return AccessModeOrErr.takeError(); 73 M.Perms = AccessModeOrErr.get(); 74 } 75 return std::move(M); 76 } 77 78 Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName, 79 bool Deterministic) { 80 sys::fs::file_status Status; 81 auto FDOrErr = sys::fs::openNativeFileForRead(FileName); 82 if (!FDOrErr) 83 return FDOrErr.takeError(); 84 sys::fs::file_t FD = *FDOrErr; 85 assert(FD != sys::fs::kInvalidFile); 86 87 if (auto EC = sys::fs::status(FD, Status)) 88 return errorCodeToError(EC); 89 90 // Opening a directory doesn't make sense. Let it fail. 91 // Linux cannot open directories with open(2), although 92 // cygwin and *bsd can. 93 if (Status.type() == sys::fs::file_type::directory_file) 94 return errorCodeToError(make_error_code(errc::is_a_directory)); 95 96 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr = 97 MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false); 98 if (!MemberBufferOrErr) 99 return errorCodeToError(MemberBufferOrErr.getError()); 100 101 if (auto EC = sys::fs::closeFile(FD)) 102 return errorCodeToError(EC); 103 104 NewArchiveMember M; 105 M.Buf = std::move(*MemberBufferOrErr); 106 M.MemberName = M.Buf->getBufferIdentifier(); 107 if (!Deterministic) { 108 M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>( 109 Status.getLastModificationTime()); 110 M.UID = Status.getUser(); 111 M.GID = Status.getGroup(); 112 M.Perms = Status.permissions(); 113 } 114 return std::move(M); 115 } 116 117 template <typename T> 118 static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) { 119 uint64_t OldPos = OS.tell(); 120 OS << Data; 121 unsigned SizeSoFar = OS.tell() - OldPos; 122 assert(SizeSoFar <= Size && "Data doesn't fit in Size"); 123 OS.indent(Size - SizeSoFar); 124 } 125 126 static bool isDarwin(object::Archive::Kind Kind) { 127 return Kind == object::Archive::K_DARWIN || 128 Kind == object::Archive::K_DARWIN64; 129 } 130 131 static bool isBSDLike(object::Archive::Kind Kind) { 132 switch (Kind) { 133 case object::Archive::K_GNU: 134 case object::Archive::K_GNU64: 135 return false; 136 case object::Archive::K_BSD: 137 case object::Archive::K_DARWIN: 138 case object::Archive::K_DARWIN64: 139 return true; 140 case object::Archive::K_COFF: 141 break; 142 } 143 llvm_unreachable("not supported for writting"); 144 } 145 146 template <class T> 147 static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) { 148 support::endian::write(Out, Val, 149 isBSDLike(Kind) ? support::little : support::big); 150 } 151 152 static void printRestOfMemberHeader( 153 raw_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime, 154 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) { 155 printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); 156 157 // The format has only 6 chars for uid and gid. Truncate if the provided 158 // values don't fit. 159 printWithSpacePadding(Out, UID % 1000000, 6); 160 printWithSpacePadding(Out, GID % 1000000, 6); 161 162 printWithSpacePadding(Out, format("%o", Perms), 8); 163 printWithSpacePadding(Out, Size, 10); 164 Out << "`\n"; 165 } 166 167 static void 168 printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name, 169 const sys::TimePoint<std::chrono::seconds> &ModTime, 170 unsigned UID, unsigned GID, unsigned Perms, 171 uint64_t Size) { 172 printWithSpacePadding(Out, Twine(Name) + "/", 16); 173 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); 174 } 175 176 static void 177 printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name, 178 const sys::TimePoint<std::chrono::seconds> &ModTime, 179 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) { 180 uint64_t PosAfterHeader = Pos + 60 + Name.size(); 181 // Pad so that even 64 bit object files are aligned. 182 unsigned Pad = offsetToAlignment(PosAfterHeader, Align(8)); 183 unsigned NameWithPadding = Name.size() + Pad; 184 printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16); 185 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, 186 NameWithPadding + Size); 187 Out << Name; 188 while (Pad--) 189 Out.write(uint8_t(0)); 190 } 191 192 static bool useStringTable(bool Thin, StringRef Name) { 193 return Thin || Name.size() >= 16 || Name.contains('/'); 194 } 195 196 static bool is64BitKind(object::Archive::Kind Kind) { 197 switch (Kind) { 198 case object::Archive::K_GNU: 199 case object::Archive::K_BSD: 200 case object::Archive::K_DARWIN: 201 case object::Archive::K_COFF: 202 return false; 203 case object::Archive::K_DARWIN64: 204 case object::Archive::K_GNU64: 205 return true; 206 } 207 llvm_unreachable("not supported for writting"); 208 } 209 210 static void 211 printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable, 212 StringMap<uint64_t> &MemberNames, object::Archive::Kind Kind, 213 bool Thin, const NewArchiveMember &M, 214 sys::TimePoint<std::chrono::seconds> ModTime, uint64_t Size) { 215 if (isBSDLike(Kind)) 216 return printBSDMemberHeader(Out, Pos, M.MemberName, ModTime, M.UID, M.GID, 217 M.Perms, Size); 218 if (!useStringTable(Thin, M.MemberName)) 219 return printGNUSmallMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID, 220 M.Perms, Size); 221 Out << '/'; 222 uint64_t NamePos; 223 if (Thin) { 224 NamePos = StringTable.tell(); 225 StringTable << M.MemberName << "/\n"; 226 } else { 227 auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)}); 228 if (Insertion.second) { 229 Insertion.first->second = StringTable.tell(); 230 StringTable << M.MemberName << "/\n"; 231 } 232 NamePos = Insertion.first->second; 233 } 234 printWithSpacePadding(Out, NamePos, 15); 235 printRestOfMemberHeader(Out, ModTime, M.UID, M.GID, M.Perms, Size); 236 } 237 238 namespace { 239 struct MemberData { 240 std::vector<unsigned> Symbols; 241 std::string Header; 242 StringRef Data; 243 StringRef Padding; 244 }; 245 } // namespace 246 247 static MemberData computeStringTable(StringRef Names) { 248 unsigned Size = Names.size(); 249 unsigned Pad = offsetToAlignment(Size, Align(2)); 250 std::string Header; 251 raw_string_ostream Out(Header); 252 printWithSpacePadding(Out, "//", 48); 253 printWithSpacePadding(Out, Size + Pad, 10); 254 Out << "`\n"; 255 Out.flush(); 256 return {{}, std::move(Header), Names, Pad ? "\n" : ""}; 257 } 258 259 static sys::TimePoint<std::chrono::seconds> now(bool Deterministic) { 260 using namespace std::chrono; 261 262 if (!Deterministic) 263 return time_point_cast<seconds>(system_clock::now()); 264 return sys::TimePoint<seconds>(); 265 } 266 267 static bool isArchiveSymbol(const object::BasicSymbolRef &S) { 268 Expected<uint32_t> SymFlagsOrErr = S.getFlags(); 269 if (!SymFlagsOrErr) 270 // TODO: Actually report errors helpfully. 271 report_fatal_error(SymFlagsOrErr.takeError()); 272 if (*SymFlagsOrErr & object::SymbolRef::SF_FormatSpecific) 273 return false; 274 if (!(*SymFlagsOrErr & object::SymbolRef::SF_Global)) 275 return false; 276 if (*SymFlagsOrErr & object::SymbolRef::SF_Undefined) 277 return false; 278 return true; 279 } 280 281 static void printNBits(raw_ostream &Out, object::Archive::Kind Kind, 282 uint64_t Val) { 283 if (is64BitKind(Kind)) 284 print<uint64_t>(Out, Kind, Val); 285 else 286 print<uint32_t>(Out, Kind, Val); 287 } 288 289 static uint64_t computeSymbolTableSize(object::Archive::Kind Kind, 290 uint64_t NumSyms, uint64_t OffsetSize, 291 StringRef StringTable, 292 uint32_t *Padding = nullptr) { 293 assert((OffsetSize == 4 || OffsetSize == 8) && "Unsupported OffsetSize"); 294 uint64_t Size = OffsetSize; // Number of entries 295 if (isBSDLike(Kind)) 296 Size += NumSyms * OffsetSize * 2; // Table 297 else 298 Size += NumSyms * OffsetSize; // Table 299 if (isBSDLike(Kind)) 300 Size += OffsetSize; // byte count 301 Size += StringTable.size(); 302 // ld64 expects the members to be 8-byte aligned for 64-bit content and at 303 // least 4-byte aligned for 32-bit content. Opt for the larger encoding 304 // uniformly. 305 // We do this for all bsd formats because it simplifies aligning members. 306 uint32_t Pad = offsetToAlignment(Size, Align(isBSDLike(Kind) ? 8 : 2)); 307 Size += Pad; 308 if (Padding) 309 *Padding = Pad; 310 return Size; 311 } 312 313 static void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind, 314 bool Deterministic, uint64_t Size) { 315 if (isBSDLike(Kind)) { 316 const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF"; 317 printBSDMemberHeader(Out, Out.tell(), Name, now(Deterministic), 0, 0, 0, 318 Size); 319 } else { 320 const char *Name = is64BitKind(Kind) ? "/SYM64" : ""; 321 printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size); 322 } 323 } 324 325 static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, 326 bool Deterministic, ArrayRef<MemberData> Members, 327 StringRef StringTable) { 328 // We don't write a symbol table on an archive with no members -- except on 329 // Darwin, where the linker will abort unless the archive has a symbol table. 330 if (StringTable.empty() && !isDarwin(Kind)) 331 return; 332 333 unsigned NumSyms = 0; 334 for (const MemberData &M : Members) 335 NumSyms += M.Symbols.size(); 336 337 uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4; 338 uint32_t Pad; 339 uint64_t Size = computeSymbolTableSize(Kind, NumSyms, OffsetSize, StringTable, &Pad); 340 writeSymbolTableHeader(Out, Kind, Deterministic, Size); 341 342 uint64_t Pos = Out.tell() + Size; 343 344 if (isBSDLike(Kind)) 345 printNBits(Out, Kind, NumSyms * 2 * OffsetSize); 346 else 347 printNBits(Out, Kind, NumSyms); 348 349 for (const MemberData &M : Members) { 350 for (unsigned StringOffset : M.Symbols) { 351 if (isBSDLike(Kind)) 352 printNBits(Out, Kind, StringOffset); 353 printNBits(Out, Kind, Pos); // member offset 354 } 355 Pos += M.Header.size() + M.Data.size() + M.Padding.size(); 356 } 357 358 if (isBSDLike(Kind)) 359 // byte count of the string table 360 printNBits(Out, Kind, StringTable.size()); 361 Out << StringTable; 362 363 while (Pad--) 364 Out.write(uint8_t(0)); 365 } 366 367 static Expected<std::vector<unsigned>> 368 getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) { 369 std::vector<unsigned> Ret; 370 371 // In the scenario when LLVMContext is populated SymbolicFile will contain a 372 // reference to it, thus SymbolicFile should be destroyed first. 373 LLVMContext Context; 374 std::unique_ptr<object::SymbolicFile> Obj; 375 376 const file_magic Type = identify_magic(Buf.getBuffer()); 377 // Treat unsupported file types as having no symbols. 378 if (!object::SymbolicFile::isSymbolicFile(Type, &Context)) 379 return Ret; 380 if (Type == file_magic::bitcode) { 381 auto ObjOrErr = object::SymbolicFile::createSymbolicFile( 382 Buf, file_magic::bitcode, &Context); 383 if (!ObjOrErr) 384 return ObjOrErr.takeError(); 385 Obj = std::move(*ObjOrErr); 386 } else { 387 auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf); 388 if (!ObjOrErr) 389 return ObjOrErr.takeError(); 390 Obj = std::move(*ObjOrErr); 391 } 392 393 HasObject = true; 394 for (const object::BasicSymbolRef &S : Obj->symbols()) { 395 if (!isArchiveSymbol(S)) 396 continue; 397 Ret.push_back(SymNames.tell()); 398 if (Error E = S.printName(SymNames)) 399 return std::move(E); 400 SymNames << '\0'; 401 } 402 return Ret; 403 } 404 405 static Expected<std::vector<MemberData>> 406 computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames, 407 object::Archive::Kind Kind, bool Thin, bool Deterministic, 408 bool NeedSymbols, ArrayRef<NewArchiveMember> NewMembers) { 409 static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'}; 410 411 // This ignores the symbol table, but we only need the value mod 8 and the 412 // symbol table is aligned to be a multiple of 8 bytes 413 uint64_t Pos = 0; 414 415 std::vector<MemberData> Ret; 416 bool HasObject = false; 417 418 // Deduplicate long member names in the string table and reuse earlier name 419 // offsets. This especially saves space for COFF Import libraries where all 420 // members have the same name. 421 StringMap<uint64_t> MemberNames; 422 423 // UniqueTimestamps is a special case to improve debugging on Darwin: 424 // 425 // The Darwin linker does not link debug info into the final 426 // binary. Instead, it emits entries of type N_OSO in in the output 427 // binary's symbol table, containing references to the linked-in 428 // object files. Using that reference, the debugger can read the 429 // debug data directly from the object files. Alternatively, an 430 // invocation of 'dsymutil' will link the debug data from the object 431 // files into a dSYM bundle, which can be loaded by the debugger, 432 // instead of the object files. 433 // 434 // For an object file, the N_OSO entries contain the absolute path 435 // path to the file, and the file's timestamp. For an object 436 // included in an archive, the path is formatted like 437 // "/absolute/path/to/archive.a(member.o)", and the timestamp is the 438 // archive member's timestamp, rather than the archive's timestamp. 439 // 440 // However, this doesn't always uniquely identify an object within 441 // an archive -- an archive file can have multiple entries with the 442 // same filename. (This will happen commonly if the original object 443 // files started in different directories.) The only way they get 444 // distinguished, then, is via the timestamp. But this process is 445 // unable to find the correct object file in the archive when there 446 // are two files of the same name and timestamp. 447 // 448 // Additionally, timestamp==0 is treated specially, and causes the 449 // timestamp to be ignored as a match criteria. 450 // 451 // That will "usually" work out okay when creating an archive not in 452 // deterministic timestamp mode, because the objects will probably 453 // have been created at different timestamps. 454 // 455 // To ameliorate this problem, in deterministic archive mode (which 456 // is the default), on Darwin we will emit a unique non-zero 457 // timestamp for each entry with a duplicated name. This is still 458 // deterministic: the only thing affecting that timestamp is the 459 // order of the files in the resultant archive. 460 // 461 // See also the functions that handle the lookup: 462 // in lldb: ObjectContainerBSDArchive::Archive::FindObject() 463 // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). 464 bool UniqueTimestamps = Deterministic && isDarwin(Kind); 465 std::map<StringRef, unsigned> FilenameCount; 466 if (UniqueTimestamps) { 467 for (const NewArchiveMember &M : NewMembers) 468 FilenameCount[M.MemberName]++; 469 for (auto &Entry : FilenameCount) 470 Entry.second = Entry.second > 1 ? 1 : 0; 471 } 472 473 for (const NewArchiveMember &M : NewMembers) { 474 std::string Header; 475 raw_string_ostream Out(Header); 476 477 MemoryBufferRef Buf = M.Buf->getMemBufferRef(); 478 StringRef Data = Thin ? "" : Buf.getBuffer(); 479 480 // ld64 expects the members to be 8-byte aligned for 64-bit content and at 481 // least 4-byte aligned for 32-bit content. Opt for the larger encoding 482 // uniformly. This matches the behaviour with cctools and ensures that ld64 483 // is happy with archives that we generate. 484 unsigned MemberPadding = 485 isDarwin(Kind) ? offsetToAlignment(Data.size(), Align(8)) : 0; 486 unsigned TailPadding = 487 offsetToAlignment(Data.size() + MemberPadding, Align(2)); 488 StringRef Padding = StringRef(PaddingData, MemberPadding + TailPadding); 489 490 sys::TimePoint<std::chrono::seconds> ModTime; 491 if (UniqueTimestamps) 492 // Increment timestamp for each file of a given name. 493 ModTime = sys::toTimePoint(FilenameCount[M.MemberName]++); 494 else 495 ModTime = M.ModTime; 496 497 uint64_t Size = Buf.getBufferSize() + MemberPadding; 498 if (Size > object::Archive::MaxMemberSize) { 499 std::string StringMsg = 500 "File " + M.MemberName.str() + " exceeds size limit"; 501 return make_error<object::GenericBinaryError>( 502 std::move(StringMsg), object::object_error::parse_failed); 503 } 504 505 printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M, 506 ModTime, Size); 507 Out.flush(); 508 509 std::vector<unsigned> Symbols; 510 if (NeedSymbols) { 511 Expected<std::vector<unsigned>> SymbolsOrErr = 512 getSymbols(Buf, SymNames, HasObject); 513 if (auto E = SymbolsOrErr.takeError()) 514 return std::move(E); 515 Symbols = std::move(*SymbolsOrErr); 516 } 517 518 Pos += Header.size() + Data.size() + Padding.size(); 519 Ret.push_back({std::move(Symbols), std::move(Header), Data, Padding}); 520 } 521 // If there are no symbols, emit an empty symbol table, to satisfy Solaris 522 // tools, older versions of which expect a symbol table in a non-empty 523 // archive, regardless of whether there are any symbols in it. 524 if (HasObject && SymNames.tell() == 0) 525 SymNames << '\0' << '\0' << '\0'; 526 return Ret; 527 } 528 529 namespace llvm { 530 531 static ErrorOr<SmallString<128>> canonicalizePath(StringRef P) { 532 SmallString<128> Ret = P; 533 std::error_code Err = sys::fs::make_absolute(Ret); 534 if (Err) 535 return Err; 536 sys::path::remove_dots(Ret, /*removedotdot*/ true); 537 return Ret; 538 } 539 540 // Compute the relative path from From to To. 541 Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To) { 542 ErrorOr<SmallString<128>> PathToOrErr = canonicalizePath(To); 543 ErrorOr<SmallString<128>> DirFromOrErr = canonicalizePath(From); 544 if (!PathToOrErr || !DirFromOrErr) 545 return errorCodeToError(std::error_code(errno, std::generic_category())); 546 547 const SmallString<128> &PathTo = *PathToOrErr; 548 const SmallString<128> &DirFrom = sys::path::parent_path(*DirFromOrErr); 549 550 // Can't construct a relative path between different roots 551 if (sys::path::root_name(PathTo) != sys::path::root_name(DirFrom)) 552 return sys::path::convert_to_slash(PathTo); 553 554 // Skip common prefixes 555 auto FromTo = 556 std::mismatch(sys::path::begin(DirFrom), sys::path::end(DirFrom), 557 sys::path::begin(PathTo)); 558 auto FromI = FromTo.first; 559 auto ToI = FromTo.second; 560 561 // Construct relative path 562 SmallString<128> Relative; 563 for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI) 564 sys::path::append(Relative, sys::path::Style::posix, ".."); 565 566 for (auto ToE = sys::path::end(PathTo); ToI != ToE; ++ToI) 567 sys::path::append(Relative, sys::path::Style::posix, *ToI); 568 569 return std::string(Relative.str()); 570 } 571 572 static Error writeArchiveToStream(raw_ostream &Out, 573 ArrayRef<NewArchiveMember> NewMembers, 574 bool WriteSymtab, object::Archive::Kind Kind, 575 bool Deterministic, bool Thin) { 576 assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode"); 577 578 SmallString<0> SymNamesBuf; 579 raw_svector_ostream SymNames(SymNamesBuf); 580 SmallString<0> StringTableBuf; 581 raw_svector_ostream StringTable(StringTableBuf); 582 583 Expected<std::vector<MemberData>> DataOrErr = 584 computeMemberData(StringTable, SymNames, Kind, Thin, Deterministic, 585 WriteSymtab, NewMembers); 586 if (Error E = DataOrErr.takeError()) 587 return E; 588 std::vector<MemberData> &Data = *DataOrErr; 589 590 if (!StringTableBuf.empty()) 591 Data.insert(Data.begin(), computeStringTable(StringTableBuf)); 592 593 // We would like to detect if we need to switch to a 64-bit symbol table. 594 if (WriteSymtab) { 595 uint64_t MaxOffset = 8; // For the file signature. 596 uint64_t LastOffset = MaxOffset; 597 uint64_t NumSyms = 0; 598 for (const auto &M : Data) { 599 // Record the start of the member's offset 600 LastOffset = MaxOffset; 601 // Account for the size of each part associated with the member. 602 MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size(); 603 NumSyms += M.Symbols.size(); 604 } 605 606 // We assume 32-bit offsets to see if 32-bit symbols are possible or not. 607 uint64_t SymtabSize = computeSymbolTableSize(Kind, NumSyms, 4, SymNamesBuf); 608 auto computeSymbolTableHeaderSize = 609 [=] { 610 SmallString<0> TmpBuf; 611 raw_svector_ostream Tmp(TmpBuf); 612 writeSymbolTableHeader(Tmp, Kind, Deterministic, SymtabSize); 613 return TmpBuf.size(); 614 }; 615 LastOffset += computeSymbolTableHeaderSize() + SymtabSize; 616 617 // The SYM64 format is used when an archive's member offsets are larger than 618 // 32-bits can hold. The need for this shift in format is detected by 619 // writeArchive. To test this we need to generate a file with a member that 620 // has an offset larger than 32-bits but this demands a very slow test. To 621 // speed the test up we use this environment variable to pretend like the 622 // cutoff happens before 32-bits and instead happens at some much smaller 623 // value. 624 uint64_t Sym64Threshold = 1ULL << 32; 625 const char *Sym64Env = std::getenv("SYM64_THRESHOLD"); 626 if (Sym64Env) 627 StringRef(Sym64Env).getAsInteger(10, Sym64Threshold); 628 629 // If LastOffset isn't going to fit in a 32-bit varible we need to switch 630 // to 64-bit. Note that the file can be larger than 4GB as long as the last 631 // member starts before the 4GB offset. 632 if (LastOffset >= Sym64Threshold) { 633 if (Kind == object::Archive::K_DARWIN) 634 Kind = object::Archive::K_DARWIN64; 635 else 636 Kind = object::Archive::K_GNU64; 637 } 638 } 639 640 if (Thin) 641 Out << "!<thin>\n"; 642 else 643 Out << "!<arch>\n"; 644 645 if (WriteSymtab) 646 writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf); 647 648 for (const MemberData &M : Data) 649 Out << M.Header << M.Data << M.Padding; 650 651 Out.flush(); 652 return Error::success(); 653 } 654 655 Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers, 656 bool WriteSymtab, object::Archive::Kind Kind, 657 bool Deterministic, bool Thin, 658 std::unique_ptr<MemoryBuffer> OldArchiveBuf) { 659 Expected<sys::fs::TempFile> Temp = 660 sys::fs::TempFile::create(ArcName + ".temp-archive-%%%%%%%.a"); 661 if (!Temp) 662 return Temp.takeError(); 663 raw_fd_ostream Out(Temp->FD, false); 664 665 if (Error E = writeArchiveToStream(Out, NewMembers, WriteSymtab, Kind, 666 Deterministic, Thin)) { 667 if (Error DiscardError = Temp->discard()) 668 return joinErrors(std::move(E), std::move(DiscardError)); 669 return E; 670 } 671 672 // At this point, we no longer need whatever backing memory 673 // was used to generate the NewMembers. On Windows, this buffer 674 // could be a mapped view of the file we want to replace (if 675 // we're updating an existing archive, say). In that case, the 676 // rename would still succeed, but it would leave behind a 677 // temporary file (actually the original file renamed) because 678 // a file cannot be deleted while there's a handle open on it, 679 // only renamed. So by freeing this buffer, this ensures that 680 // the last open handle on the destination file, if any, is 681 // closed before we attempt to rename. 682 OldArchiveBuf.reset(); 683 684 return Temp->keep(ArcName); 685 } 686 687 Expected<std::unique_ptr<MemoryBuffer>> 688 writeArchiveToBuffer(ArrayRef<NewArchiveMember> NewMembers, bool WriteSymtab, 689 object::Archive::Kind Kind, bool Deterministic, 690 bool Thin) { 691 SmallVector<char, 0> ArchiveBufferVector; 692 raw_svector_ostream ArchiveStream(ArchiveBufferVector); 693 694 if (Error E = writeArchiveToStream(ArchiveStream, NewMembers, WriteSymtab, 695 Kind, Deterministic, Thin)) 696 return std::move(E); 697 698 return std::make_unique<SmallVectorMemoryBuffer>( 699 std::move(ArchiveBufferVector)); 700 } 701 702 } // namespace llvm 703