Index: lib/Object/ArchiveWriter.cpp =================================================================== --- lib/Object/ArchiveWriter.cpp +++ lib/Object/ArchiveWriter.cpp @@ -1,612 +1,635 @@ -//===- ArchiveWriter.cpp - ar File Format implementation --------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the writeArchive function. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Object/ArchiveWriter.h" -#include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/BinaryFormat/Magic.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/Object/Archive.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Object/SymbolicFile.h" -#include "llvm/Support/EndianStream.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/Format.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/ToolOutputFile.h" -#include "llvm/Support/raw_ostream.h" - -#include - -#if !defined(_MSC_VER) && !defined(__MINGW32__) -#include -#else -#include -#endif - -using namespace llvm; - -NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef) - : Buf(MemoryBuffer::getMemBuffer(BufRef, false)), - MemberName(BufRef.getBufferIdentifier()) {} - -Expected -NewArchiveMember::getOldMember(const object::Archive::Child &OldMember, - bool Deterministic) { - Expected BufOrErr = OldMember.getMemoryBufferRef(); - if (!BufOrErr) - return BufOrErr.takeError(); - - NewArchiveMember M; - M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false); - M.MemberName = M.Buf->getBufferIdentifier(); - if (!Deterministic) { - auto ModTimeOrErr = OldMember.getLastModified(); - if (!ModTimeOrErr) - return ModTimeOrErr.takeError(); - M.ModTime = ModTimeOrErr.get(); - Expected UIDOrErr = OldMember.getUID(); - if (!UIDOrErr) - return UIDOrErr.takeError(); - M.UID = UIDOrErr.get(); - Expected GIDOrErr = OldMember.getGID(); - if (!GIDOrErr) - return GIDOrErr.takeError(); - M.GID = GIDOrErr.get(); - Expected AccessModeOrErr = OldMember.getAccessMode(); - if (!AccessModeOrErr) - return AccessModeOrErr.takeError(); - M.Perms = AccessModeOrErr.get(); - } - return std::move(M); -} - -Expected NewArchiveMember::getFile(StringRef FileName, - bool Deterministic) { - sys::fs::file_status Status; - int FD; - if (auto EC = sys::fs::openFileForRead(FileName, FD)) - return errorCodeToError(EC); - assert(FD != -1); - - if (auto EC = sys::fs::status(FD, Status)) - return errorCodeToError(EC); - - // Opening a directory doesn't make sense. Let it fail. - // Linux cannot open directories with open(2), although - // cygwin and *bsd can. - if (Status.type() == sys::fs::file_type::directory_file) - return errorCodeToError(make_error_code(errc::is_a_directory)); - - ErrorOr> MemberBufferOrErr = - MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false); - if (!MemberBufferOrErr) - return errorCodeToError(MemberBufferOrErr.getError()); - - if (close(FD) != 0) - return errorCodeToError(std::error_code(errno, std::generic_category())); - - NewArchiveMember M; - M.Buf = std::move(*MemberBufferOrErr); - M.MemberName = M.Buf->getBufferIdentifier(); - if (!Deterministic) { - M.ModTime = std::chrono::time_point_cast( - Status.getLastModificationTime()); - M.UID = Status.getUser(); - M.GID = Status.getGroup(); - M.Perms = Status.permissions(); - } - return std::move(M); -} - -template -static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) { - uint64_t OldPos = OS.tell(); - OS << Data; - unsigned SizeSoFar = OS.tell() - OldPos; - assert(SizeSoFar <= Size && "Data doesn't fit in Size"); - OS.indent(Size - SizeSoFar); -} - -static bool isDarwin(object::Archive::Kind Kind) { - return Kind == object::Archive::K_DARWIN || - Kind == object::Archive::K_DARWIN64; -} - -static bool isBSDLike(object::Archive::Kind Kind) { - switch (Kind) { - case object::Archive::K_GNU: - case object::Archive::K_GNU64: - return false; - case object::Archive::K_BSD: - case object::Archive::K_DARWIN: - case object::Archive::K_DARWIN64: - return true; - case object::Archive::K_COFF: - break; - } - llvm_unreachable("not supported for writting"); -} - -template -static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) { - support::endian::write(Out, Val, - isBSDLike(Kind) ? support::little : support::big); -} - -static void printRestOfMemberHeader( - raw_ostream &Out, const sys::TimePoint &ModTime, - unsigned UID, unsigned GID, unsigned Perms, unsigned Size) { - printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); - - // The format has only 6 chars for uid and gid. Truncate if the provided - // values don't fit. - printWithSpacePadding(Out, UID % 1000000, 6); - printWithSpacePadding(Out, GID % 1000000, 6); - - printWithSpacePadding(Out, format("%o", Perms), 8); - printWithSpacePadding(Out, Size, 10); - Out << "`\n"; -} - -static void -printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name, - const sys::TimePoint &ModTime, - unsigned UID, unsigned GID, unsigned Perms, - unsigned Size) { - printWithSpacePadding(Out, Twine(Name) + "/", 16); - printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); -} - -static void -printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name, - const sys::TimePoint &ModTime, - unsigned UID, unsigned GID, unsigned Perms, - unsigned Size) { - uint64_t PosAfterHeader = Pos + 60 + Name.size(); - // Pad so that even 64 bit object files are aligned. - unsigned Pad = OffsetToAlignment(PosAfterHeader, 8); - unsigned NameWithPadding = Name.size() + Pad; - printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16); - printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, - NameWithPadding + Size); - Out << Name; - while (Pad--) - Out.write(uint8_t(0)); -} - -static bool useStringTable(bool Thin, StringRef Name) { - return Thin || Name.size() >= 16 || Name.contains('/'); -} - -static bool is64BitKind(object::Archive::Kind Kind) { - switch (Kind) { - case object::Archive::K_GNU: - case object::Archive::K_BSD: - case object::Archive::K_DARWIN: - case object::Archive::K_COFF: - return false; - case object::Archive::K_DARWIN64: - case object::Archive::K_GNU64: - return true; - } - llvm_unreachable("not supported for writting"); -} - -static void -printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable, - StringMap &MemberNames, object::Archive::Kind Kind, - bool Thin, const NewArchiveMember &M, - sys::TimePoint ModTime, unsigned Size) { - if (isBSDLike(Kind)) - return printBSDMemberHeader(Out, Pos, M.MemberName, ModTime, M.UID, M.GID, - M.Perms, Size); - if (!useStringTable(Thin, M.MemberName)) - return printGNUSmallMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID, - M.Perms, Size); - Out << '/'; - uint64_t NamePos; - if (Thin) { - NamePos = StringTable.tell(); - StringTable << M.MemberName << "/\n"; - } else { - auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)}); - if (Insertion.second) { - Insertion.first->second = StringTable.tell(); - StringTable << M.MemberName << "/\n"; - } - NamePos = Insertion.first->second; - } - printWithSpacePadding(Out, NamePos, 15); - printRestOfMemberHeader(Out, ModTime, M.UID, M.GID, M.Perms, Size); -} - -namespace { -struct MemberData { - std::vector Symbols; - std::string Header; - StringRef Data; - StringRef Padding; -}; -} // namespace - -static MemberData computeStringTable(StringRef Names) { - unsigned Size = Names.size(); - unsigned Pad = OffsetToAlignment(Size, 2); - std::string Header; - raw_string_ostream Out(Header); - printWithSpacePadding(Out, "//", 48); - printWithSpacePadding(Out, Size + Pad, 10); - Out << "`\n"; - Out.flush(); - return {{}, std::move(Header), Names, Pad ? "\n" : ""}; -} - -static sys::TimePoint now(bool Deterministic) { - using namespace std::chrono; - - if (!Deterministic) - return time_point_cast(system_clock::now()); - return sys::TimePoint(); -} - -static bool isArchiveSymbol(const object::BasicSymbolRef &S) { - uint32_t Symflags = S.getFlags(); - if (Symflags & object::SymbolRef::SF_FormatSpecific) - return false; - if (!(Symflags & object::SymbolRef::SF_Global)) - return false; - if (Symflags & object::SymbolRef::SF_Undefined) - return false; - return true; -} - -static void printNBits(raw_ostream &Out, object::Archive::Kind Kind, - uint64_t Val) { - if (is64BitKind(Kind)) - print(Out, Kind, Val); - else - print(Out, Kind, Val); -} - -static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, - bool Deterministic, ArrayRef Members, - StringRef StringTable) { - // We don't write a symbol table on an archive with no members -- except on - // Darwin, where the linker will abort unless the archive has a symbol table. - if (StringTable.empty() && !isDarwin(Kind)) - return; - - unsigned NumSyms = 0; - for (const MemberData &M : Members) - NumSyms += M.Symbols.size(); - - unsigned Size = 0; - unsigned OffsetSize = is64BitKind(Kind) ? sizeof(uint64_t) : sizeof(uint32_t); - - Size += OffsetSize; // Number of entries - if (isBSDLike(Kind)) - Size += NumSyms * OffsetSize * 2; // Table - else - Size += NumSyms * OffsetSize; // Table - if (isBSDLike(Kind)) - Size += OffsetSize; // byte count - Size += StringTable.size(); - // ld64 expects the members to be 8-byte aligned for 64-bit content and at - // least 4-byte aligned for 32-bit content. Opt for the larger encoding - // uniformly. - // We do this for all bsd formats because it simplifies aligning members. - unsigned Alignment = isBSDLike(Kind) ? 8 : 2; - unsigned Pad = OffsetToAlignment(Size, Alignment); - Size += Pad; - - if (isBSDLike(Kind)) { - const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF"; - printBSDMemberHeader(Out, Out.tell(), Name, now(Deterministic), 0, 0, 0, - Size); - } else { - const char *Name = is64BitKind(Kind) ? "/SYM64" : ""; - printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size); - } - - uint64_t Pos = Out.tell() + Size; - - if (isBSDLike(Kind)) - printNBits(Out, Kind, NumSyms * 2 * OffsetSize); - else - printNBits(Out, Kind, NumSyms); - - for (const MemberData &M : Members) { - for (unsigned StringOffset : M.Symbols) { - if (isBSDLike(Kind)) - printNBits(Out, Kind, StringOffset); - printNBits(Out, Kind, Pos); // member offset - } - Pos += M.Header.size() + M.Data.size() + M.Padding.size(); - } - - if (isBSDLike(Kind)) - // byte count of the string table - printNBits(Out, Kind, StringTable.size()); - Out << StringTable; - - while (Pad--) - Out.write(uint8_t(0)); -} - -static Expected> -getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) { - std::vector Ret; - - // In the scenario when LLVMContext is populated SymbolicFile will contain a - // reference to it, thus SymbolicFile should be destroyed first. - LLVMContext Context; - std::unique_ptr Obj; - if (identify_magic(Buf.getBuffer()) == file_magic::bitcode) { - auto ObjOrErr = object::SymbolicFile::createSymbolicFile( - Buf, file_magic::bitcode, &Context); - if (!ObjOrErr) { - // FIXME: check only for "not an object file" errors. - consumeError(ObjOrErr.takeError()); - return Ret; - } - Obj = std::move(*ObjOrErr); - } else { - auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf); - if (!ObjOrErr) { - // FIXME: check only for "not an object file" errors. - consumeError(ObjOrErr.takeError()); - return Ret; - } - Obj = std::move(*ObjOrErr); - } - - HasObject = true; - for (const object::BasicSymbolRef &S : Obj->symbols()) { - if (!isArchiveSymbol(S)) - continue; - Ret.push_back(SymNames.tell()); - if (auto EC = S.printName(SymNames)) - return errorCodeToError(EC); - SymNames << '\0'; - } - return Ret; -} - -static Expected> -computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames, - object::Archive::Kind Kind, bool Thin, bool Deterministic, - ArrayRef NewMembers) { - static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'}; - - // This ignores the symbol table, but we only need the value mod 8 and the - // symbol table is aligned to be a multiple of 8 bytes - uint64_t Pos = 0; - - std::vector Ret; - bool HasObject = false; - - // Deduplicate long member names in the string table and reuse earlier name - // offsets. This especially saves space for COFF Import libraries where all - // members have the same name. - StringMap MemberNames; - - // UniqueTimestamps is a special case to improve debugging on Darwin: - // - // The Darwin linker does not link debug info into the final - // binary. Instead, it emits entries of type N_OSO in in the output - // binary's symbol table, containing references to the linked-in - // object files. Using that reference, the debugger can read the - // debug data directly from the object files. Alternatively, an - // invocation of 'dsymutil' will link the debug data from the object - // files into a dSYM bundle, which can be loaded by the debugger, - // instead of the object files. - // - // For an object file, the N_OSO entries contain the absolute path - // path to the file, and the file's timestamp. For an object - // included in an archive, the path is formatted like - // "/absolute/path/to/archive.a(member.o)", and the timestamp is the - // archive member's timestamp, rather than the archive's timestamp. - // - // However, this doesn't always uniquely identify an object within - // an archive -- an archive file can have multiple entries with the - // same filename. (This will happen commonly if the original object - // files started in different directories.) The only way they get - // distinguished, then, is via the timestamp. But this process is - // unable to find the correct object file in the archive when there - // are two files of the same name and timestamp. - // - // Additionally, timestamp==0 is treated specially, and causes the - // timestamp to be ignored as a match criteria. - // - // That will "usually" work out okay when creating an archive not in - // deterministic timestamp mode, because the objects will probably - // have been created at different timestamps. - // - // To ameliorate this problem, in deterministic archive mode (which - // is the default), on Darwin we will emit a unique non-zero - // timestamp for each entry with a duplicated name. This is still - // deterministic: the only thing affecting that timestamp is the - // order of the files in the resultant archive. - // - // See also the functions that handle the lookup: - // in lldb: ObjectContainerBSDArchive::Archive::FindObject() - // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). - bool UniqueTimestamps = Deterministic && isDarwin(Kind); - std::map FilenameCount; - if (UniqueTimestamps) { - for (const NewArchiveMember &M : NewMembers) - FilenameCount[M.MemberName]++; - for (auto &Entry : FilenameCount) - Entry.second = Entry.second > 1 ? 1 : 0; - } - - for (const NewArchiveMember &M : NewMembers) { - std::string Header; - raw_string_ostream Out(Header); - - MemoryBufferRef Buf = M.Buf->getMemBufferRef(); - StringRef Data = Thin ? "" : Buf.getBuffer(); - - // ld64 expects the members to be 8-byte aligned for 64-bit content and at - // least 4-byte aligned for 32-bit content. Opt for the larger encoding - // uniformly. This matches the behaviour with cctools and ensures that ld64 - // is happy with archives that we generate. - unsigned MemberPadding = - isDarwin(Kind) ? OffsetToAlignment(Data.size(), 8) : 0; - unsigned TailPadding = OffsetToAlignment(Data.size() + MemberPadding, 2); - StringRef Padding = StringRef(PaddingData, MemberPadding + TailPadding); - - sys::TimePoint ModTime; - if (UniqueTimestamps) - // Increment timestamp for each file of a given name. - ModTime = sys::toTimePoint(FilenameCount[M.MemberName]++); - else - ModTime = M.ModTime; - printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M, - ModTime, Buf.getBufferSize() + MemberPadding); - Out.flush(); - - Expected> Symbols = - getSymbols(Buf, SymNames, HasObject); - if (auto E = Symbols.takeError()) - return std::move(E); - - Pos += Header.size() + Data.size() + Padding.size(); - Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding}); - } - // If there are no symbols, emit an empty symbol table, to satisfy Solaris - // tools, older versions of which expect a symbol table in a non-empty - // archive, regardless of whether there are any symbols in it. - if (HasObject && SymNames.tell() == 0) - SymNames << '\0' << '\0' << '\0'; - return Ret; -} - -namespace llvm { -// Compute the relative path from From to To. -std::string computeArchiveRelativePath(StringRef From, StringRef To) { - if (sys::path::is_absolute(From) || sys::path::is_absolute(To)) - return To; - - StringRef DirFrom = sys::path::parent_path(From); - auto FromI = sys::path::begin(DirFrom); - auto ToI = sys::path::begin(To); - while (*FromI == *ToI) { - ++FromI; - ++ToI; - } - - SmallString<128> Relative; - for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI) - sys::path::append(Relative, ".."); - - for (auto ToE = sys::path::end(To); ToI != ToE; ++ToI) - sys::path::append(Relative, *ToI); - - // Replace backslashes with slashes so that the path is portable between *nix - // and Windows. - return sys::path::convert_to_slash(Relative); -} - -Error writeArchive(StringRef ArcName, ArrayRef NewMembers, - bool WriteSymtab, object::Archive::Kind Kind, - bool Deterministic, bool Thin, - std::unique_ptr OldArchiveBuf) { - assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode"); - - SmallString<0> SymNamesBuf; - raw_svector_ostream SymNames(SymNamesBuf); - SmallString<0> StringTableBuf; - raw_svector_ostream StringTable(StringTableBuf); - - Expected> DataOrErr = computeMemberData( - StringTable, SymNames, Kind, Thin, Deterministic, NewMembers); - if (Error E = DataOrErr.takeError()) - return E; - std::vector &Data = *DataOrErr; - - if (!StringTableBuf.empty()) - Data.insert(Data.begin(), computeStringTable(StringTableBuf)); - - // We would like to detect if we need to switch to a 64-bit symbol table. - if (WriteSymtab) { - uint64_t MaxOffset = 0; - uint64_t LastOffset = MaxOffset; - for (const auto &M : Data) { - // Record the start of the member's offset - LastOffset = MaxOffset; - // Account for the size of each part associated with the member. - MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size(); - // We assume 32-bit symbols to see if 32-bit symbols are possible or not. - MaxOffset += M.Symbols.size() * 4; - } - - // The SYM64 format is used when an archive's member offsets are larger than - // 32-bits can hold. The need for this shift in format is detected by - // writeArchive. To test this we need to generate a file with a member that - // has an offset larger than 32-bits but this demands a very slow test. To - // speed the test up we use this environment variable to pretend like the - // cutoff happens before 32-bits and instead happens at some much smaller - // value. - const char *Sym64Env = std::getenv("SYM64_THRESHOLD"); - int Sym64Threshold = 32; - if (Sym64Env) - StringRef(Sym64Env).getAsInteger(10, Sym64Threshold); - - // If LastOffset isn't going to fit in a 32-bit varible we need to switch - // to 64-bit. Note that the file can be larger than 4GB as long as the last - // member starts before the 4GB offset. - if (LastOffset >= (1ULL << Sym64Threshold)) { - if (Kind == object::Archive::K_DARWIN) - Kind = object::Archive::K_DARWIN64; - else - Kind = object::Archive::K_GNU64; - } - } - - Expected Temp = - sys::fs::TempFile::create(ArcName + ".temp-archive-%%%%%%%.a"); - if (!Temp) - return Temp.takeError(); - - raw_fd_ostream Out(Temp->FD, false); - if (Thin) - Out << "!\n"; - else - Out << "!\n"; - - if (WriteSymtab) - writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf); - - for (const MemberData &M : Data) - Out << M.Header << M.Data << M.Padding; - - Out.flush(); - - // At this point, we no longer need whatever backing memory - // was used to generate the NewMembers. On Windows, this buffer - // could be a mapped view of the file we want to replace (if - // we're updating an existing archive, say). In that case, the - // rename would still succeed, but it would leave behind a - // temporary file (actually the original file renamed) because - // a file cannot be deleted while there's a handle open on it, - // only renamed. So by freeing this buffer, this ensures that - // the last open handle on the destination file, if any, is - // closed before we attempt to rename. - OldArchiveBuf.reset(); - - return Temp->keep(ArcName); -} - -} // namespace llvm +//===- ArchiveWriter.cpp - ar File Format implementation --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the writeArchive function. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Object/ArchiveWriter.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/BinaryFormat/Magic.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/Object/Archive.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Object/SymbolicFile.h" +#include "llvm/Support/EndianStream.h" +#include "llvm/Support/Errc.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/Format.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Support/raw_ostream.h" + +#include + +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#else +#include +#endif + +using namespace llvm; + +NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef) + : Buf(MemoryBuffer::getMemBuffer(BufRef, false)), + MemberName(BufRef.getBufferIdentifier()) {} + +Expected +NewArchiveMember::getOldMember(const object::Archive::Child &OldMember, + bool Deterministic) { + Expected BufOrErr = OldMember.getMemoryBufferRef(); + if (!BufOrErr) + return BufOrErr.takeError(); + + NewArchiveMember M; + M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false); + M.MemberName = M.Buf->getBufferIdentifier(); + if (!Deterministic) { + auto ModTimeOrErr = OldMember.getLastModified(); + if (!ModTimeOrErr) + return ModTimeOrErr.takeError(); + M.ModTime = ModTimeOrErr.get(); + Expected UIDOrErr = OldMember.getUID(); + if (!UIDOrErr) + return UIDOrErr.takeError(); + M.UID = UIDOrErr.get(); + Expected GIDOrErr = OldMember.getGID(); + if (!GIDOrErr) + return GIDOrErr.takeError(); + M.GID = GIDOrErr.get(); + Expected AccessModeOrErr = OldMember.getAccessMode(); + if (!AccessModeOrErr) + return AccessModeOrErr.takeError(); + M.Perms = AccessModeOrErr.get(); + } + return std::move(M); +} + +Expected NewArchiveMember::getFile(StringRef FileName, + bool Deterministic) { + sys::fs::file_status Status; + int FD; + if (auto EC = sys::fs::openFileForRead(FileName, FD)) + return errorCodeToError(EC); + assert(FD != -1); + + if (auto EC = sys::fs::status(FD, Status)) + return errorCodeToError(EC); + + // Opening a directory doesn't make sense. Let it fail. + // Linux cannot open directories with open(2), although + // cygwin and *bsd can. + if (Status.type() == sys::fs::file_type::directory_file) + return errorCodeToError(make_error_code(errc::is_a_directory)); + + ErrorOr> MemberBufferOrErr = + MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false); + if (!MemberBufferOrErr) + return errorCodeToError(MemberBufferOrErr.getError()); + + if (close(FD) != 0) + return errorCodeToError(std::error_code(errno, std::generic_category())); + + NewArchiveMember M; + M.Buf = std::move(*MemberBufferOrErr); + M.MemberName = M.Buf->getBufferIdentifier(); + if (!Deterministic) { + M.ModTime = std::chrono::time_point_cast( + Status.getLastModificationTime()); + M.UID = Status.getUser(); + M.GID = Status.getGroup(); + M.Perms = Status.permissions(); + } + return std::move(M); +} + +template +static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) { + uint64_t OldPos = OS.tell(); + OS << Data; + unsigned SizeSoFar = OS.tell() - OldPos; + assert(SizeSoFar <= Size && "Data doesn't fit in Size"); + OS.indent(Size - SizeSoFar); +} + +static bool isDarwin(object::Archive::Kind Kind) { + return Kind == object::Archive::K_DARWIN || + Kind == object::Archive::K_DARWIN64; +} + +static bool isBSDLike(object::Archive::Kind Kind) { + switch (Kind) { + case object::Archive::K_GNU: + case object::Archive::K_GNU64: + return false; + case object::Archive::K_BSD: + case object::Archive::K_DARWIN: + case object::Archive::K_DARWIN64: + return true; + case object::Archive::K_COFF: + break; + } + llvm_unreachable("not supported for writting"); +} + +template +static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) { + support::endian::write(Out, Val, + isBSDLike(Kind) ? support::little : support::big); +} + +static void printRestOfMemberHeader( + raw_ostream &Out, const sys::TimePoint &ModTime, + unsigned UID, unsigned GID, unsigned Perms, unsigned Size) { + printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); + + // The format has only 6 chars for uid and gid. Truncate if the provided + // values don't fit. + printWithSpacePadding(Out, UID % 1000000, 6); + printWithSpacePadding(Out, GID % 1000000, 6); + + printWithSpacePadding(Out, format("%o", Perms), 8); + printWithSpacePadding(Out, Size, 10); + Out << "`\n"; +} + +static void +printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name, + const sys::TimePoint &ModTime, + unsigned UID, unsigned GID, unsigned Perms, + unsigned Size) { + printWithSpacePadding(Out, Twine(Name) + "/", 16); + printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); +} + +static void +printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name, + const sys::TimePoint &ModTime, + unsigned UID, unsigned GID, unsigned Perms, + unsigned Size) { + uint64_t PosAfterHeader = Pos + 60 + Name.size(); + // Pad so that even 64 bit object files are aligned. + unsigned Pad = OffsetToAlignment(PosAfterHeader, 8); + unsigned NameWithPadding = Name.size() + Pad; + printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16); + printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, + NameWithPadding + Size); + Out << Name; + while (Pad--) + Out.write(uint8_t(0)); +} + +static bool useStringTable(bool Thin, StringRef Name) { + return Thin || Name.size() >= 16 || Name.contains('/'); +} + +static bool is64BitKind(object::Archive::Kind Kind) { + switch (Kind) { + case object::Archive::K_GNU: + case object::Archive::K_BSD: + case object::Archive::K_DARWIN: + case object::Archive::K_COFF: + return false; + case object::Archive::K_DARWIN64: + case object::Archive::K_GNU64: + return true; + } + llvm_unreachable("not supported for writting"); +} + +static void +printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable, + StringMap &MemberNames, object::Archive::Kind Kind, + bool Thin, const NewArchiveMember &M, + sys::TimePoint ModTime, unsigned Size) { + if (isBSDLike(Kind)) + return printBSDMemberHeader(Out, Pos, M.MemberName, ModTime, M.UID, M.GID, + M.Perms, Size); + if (!useStringTable(Thin, M.MemberName)) + return printGNUSmallMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID, + M.Perms, Size); + Out << '/'; + uint64_t NamePos; + if (Thin) { + NamePos = StringTable.tell(); + StringTable << M.MemberName << "/\n"; + } else { + auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)}); + if (Insertion.second) { + Insertion.first->second = StringTable.tell(); + StringTable << M.MemberName << "/\n"; + } + NamePos = Insertion.first->second; + } + printWithSpacePadding(Out, NamePos, 15); + printRestOfMemberHeader(Out, ModTime, M.UID, M.GID, M.Perms, Size); +} + +namespace { +struct MemberData { + std::vector Symbols; + std::string Header; + StringRef Data; + StringRef Padding; +}; +} // namespace + +static MemberData computeStringTable(StringRef Names) { + unsigned Size = Names.size(); + unsigned Pad = OffsetToAlignment(Size, 2); + std::string Header; + raw_string_ostream Out(Header); + printWithSpacePadding(Out, "//", 48); + printWithSpacePadding(Out, Size + Pad, 10); + Out << "`\n"; + Out.flush(); + return {{}, std::move(Header), Names, Pad ? "\n" : ""}; +} + +static sys::TimePoint now(bool Deterministic) { + using namespace std::chrono; + + if (!Deterministic) + return time_point_cast(system_clock::now()); + return sys::TimePoint(); +} + +static bool isArchiveSymbol(const object::BasicSymbolRef &S) { + uint32_t Symflags = S.getFlags(); + if (Symflags & object::SymbolRef::SF_FormatSpecific) + return false; + if (!(Symflags & object::SymbolRef::SF_Global)) + return false; + if (Symflags & object::SymbolRef::SF_Undefined) + return false; + return true; +} + +static void printNBits(raw_ostream &Out, object::Archive::Kind Kind, + uint64_t Val) { + if (is64BitKind(Kind)) + print(Out, Kind, Val); + else + print(Out, Kind, Val); +} + +static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, + bool Deterministic, ArrayRef Members, + StringRef StringTable) { + // We don't write a symbol table on an archive with no members -- except on + // Darwin, where the linker will abort unless the archive has a symbol table. + if (StringTable.empty() && !isDarwin(Kind)) + return; + + unsigned NumSyms = 0; + for (const MemberData &M : Members) + NumSyms += M.Symbols.size(); + + unsigned Size = 0; + unsigned OffsetSize = is64BitKind(Kind) ? sizeof(uint64_t) : sizeof(uint32_t); + + Size += OffsetSize; // Number of entries + if (isBSDLike(Kind)) + Size += NumSyms * OffsetSize * 2; // Table + else + Size += NumSyms * OffsetSize; // Table + if (isBSDLike(Kind)) + Size += OffsetSize; // byte count + Size += StringTable.size(); + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. + // We do this for all bsd formats because it simplifies aligning members. + unsigned Alignment = isBSDLike(Kind) ? 8 : 2; + unsigned Pad = OffsetToAlignment(Size, Alignment); + Size += Pad; + + if (isBSDLike(Kind)) { + const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF"; + printBSDMemberHeader(Out, Out.tell(), Name, now(Deterministic), 0, 0, 0, + Size); + } else { + const char *Name = is64BitKind(Kind) ? "/SYM64" : ""; + printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size); + } + + uint64_t Pos = Out.tell() + Size; + + if (isBSDLike(Kind)) + printNBits(Out, Kind, NumSyms * 2 * OffsetSize); + else + printNBits(Out, Kind, NumSyms); + + for (const MemberData &M : Members) { + for (unsigned StringOffset : M.Symbols) { + if (isBSDLike(Kind)) + printNBits(Out, Kind, StringOffset); + printNBits(Out, Kind, Pos); // member offset + } + Pos += M.Header.size() + M.Data.size() + M.Padding.size(); + } + + if (isBSDLike(Kind)) + // byte count of the string table + printNBits(Out, Kind, StringTable.size()); + Out << StringTable; + + while (Pad--) + Out.write(uint8_t(0)); +} + +static Expected> +getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) { + std::vector Ret; + + // In the scenario when LLVMContext is populated SymbolicFile will contain a + // reference to it, thus SymbolicFile should be destroyed first. + LLVMContext Context; + std::unique_ptr Obj; + if (identify_magic(Buf.getBuffer()) == file_magic::bitcode) { + auto ObjOrErr = object::SymbolicFile::createSymbolicFile( + Buf, file_magic::bitcode, &Context); + if (!ObjOrErr) { + // FIXME: check only for "not an object file" errors. + consumeError(ObjOrErr.takeError()); + return Ret; + } + Obj = std::move(*ObjOrErr); + } else { + auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf); + if (!ObjOrErr) { + // FIXME: check only for "not an object file" errors. + consumeError(ObjOrErr.takeError()); + return Ret; + } + Obj = std::move(*ObjOrErr); + } + + HasObject = true; + for (const object::BasicSymbolRef &S : Obj->symbols()) { + if (!isArchiveSymbol(S)) + continue; + Ret.push_back(SymNames.tell()); + if (auto EC = S.printName(SymNames)) + return errorCodeToError(EC); + SymNames << '\0'; + } + return Ret; +} + +static Expected> +computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames, + object::Archive::Kind Kind, bool Thin, bool Deterministic, + ArrayRef NewMembers) { + static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'}; + + // This ignores the symbol table, but we only need the value mod 8 and the + // symbol table is aligned to be a multiple of 8 bytes + uint64_t Pos = 0; + + std::vector Ret; + bool HasObject = false; + + // Deduplicate long member names in the string table and reuse earlier name + // offsets. This especially saves space for COFF Import libraries where all + // members have the same name. + StringMap MemberNames; + + // UniqueTimestamps is a special case to improve debugging on Darwin: + // + // The Darwin linker does not link debug info into the final + // binary. Instead, it emits entries of type N_OSO in in the output + // binary's symbol table, containing references to the linked-in + // object files. Using that reference, the debugger can read the + // debug data directly from the object files. Alternatively, an + // invocation of 'dsymutil' will link the debug data from the object + // files into a dSYM bundle, which can be loaded by the debugger, + // instead of the object files. + // + // For an object file, the N_OSO entries contain the absolute path + // path to the file, and the file's timestamp. For an object + // included in an archive, the path is formatted like + // "/absolute/path/to/archive.a(member.o)", and the timestamp is the + // archive member's timestamp, rather than the archive's timestamp. + // + // However, this doesn't always uniquely identify an object within + // an archive -- an archive file can have multiple entries with the + // same filename. (This will happen commonly if the original object + // files started in different directories.) The only way they get + // distinguished, then, is via the timestamp. But this process is + // unable to find the correct object file in the archive when there + // are two files of the same name and timestamp. + // + // Additionally, timestamp==0 is treated specially, and causes the + // timestamp to be ignored as a match criteria. + // + // That will "usually" work out okay when creating an archive not in + // deterministic timestamp mode, because the objects will probably + // have been created at different timestamps. + // + // To ameliorate this problem, in deterministic archive mode (which + // is the default), on Darwin we will emit a unique non-zero + // timestamp for each entry with a duplicated name. This is still + // deterministic: the only thing affecting that timestamp is the + // order of the files in the resultant archive. + // + // See also the functions that handle the lookup: + // in lldb: ObjectContainerBSDArchive::Archive::FindObject() + // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). + bool UniqueTimestamps = Deterministic && isDarwin(Kind); + std::map FilenameCount; + if (UniqueTimestamps) { + for (const NewArchiveMember &M : NewMembers) + FilenameCount[M.MemberName]++; + for (auto &Entry : FilenameCount) + Entry.second = Entry.second > 1 ? 1 : 0; + } + + for (const NewArchiveMember &M : NewMembers) { + std::string Header; + raw_string_ostream Out(Header); + + MemoryBufferRef Buf = M.Buf->getMemBufferRef(); + StringRef Data = Thin ? "" : Buf.getBuffer(); + + // ld64 expects the members to be 8-byte aligned for 64-bit content and at + // least 4-byte aligned for 32-bit content. Opt for the larger encoding + // uniformly. This matches the behaviour with cctools and ensures that ld64 + // is happy with archives that we generate. + unsigned MemberPadding = + isDarwin(Kind) ? OffsetToAlignment(Data.size(), 8) : 0; + unsigned TailPadding = OffsetToAlignment(Data.size() + MemberPadding, 2); + StringRef Padding = StringRef(PaddingData, MemberPadding + TailPadding); + + sys::TimePoint ModTime; + if (UniqueTimestamps) + // Increment timestamp for each file of a given name. + ModTime = sys::toTimePoint(FilenameCount[M.MemberName]++); + else + ModTime = M.ModTime; + printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M, + ModTime, Buf.getBufferSize() + MemberPadding); + Out.flush(); + + Expected> Symbols = + getSymbols(Buf, SymNames, HasObject); + if (auto E = Symbols.takeError()) + return std::move(E); + + Pos += Header.size() + Data.size() + Padding.size(); + Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding}); + } + // If there are no symbols, emit an empty symbol table, to satisfy Solaris + // tools, older versions of which expect a symbol table in a non-empty + // archive, regardless of whether there are any symbols in it. + if (HasObject && SymNames.tell() == 0) + SymNames << '\0' << '\0' << '\0'; + return Ret; +} + +namespace llvm { +// Compute the relative path from From to To. +std::string computeArchiveRelativePath(StringRef From, StringRef To) { + auto getDotlessAbsolutePath = [](StringRef P) -> ErrorOr> { + SmallString<128> Ret = P; + std::error_code Err = sys::fs::make_absolute(Ret); + if (Err) + return Err; + sys::path::remove_dots(Ret, /*removedotdot*/ true); +#ifdef _WIN32 + // Canonicalise '\\' to '/' as sys::path::const_iterator may return a UNC + // specifier. It also returns the first directory separator after a drive + // letter or UNC specifier as a component of the path. + std::replace(Ret.begin(), Ret.end(), '\\', '/'); +#endif + return Ret; + }; + + ErrorOr> PathToOrErr = getDotlessAbsolutePath(To); + ErrorOr> DirFromOrErr = + getDotlessAbsolutePath(sys::path::parent_path(From)); + if (!PathToOrErr || !DirFromOrErr) + return sys::path::convert_to_slash(To); + + const SmallString<128> &PathTo = *PathToOrErr; + const SmallString<128> &DirFrom = *DirFromOrErr; + + auto FromS = sys::path::begin(DirFrom); + auto FromI = FromS; + auto ToI = sys::path::begin(PathTo); + while (*FromI == *ToI) { + ++FromI; + ++ToI; + } + + // Can't construct a relative path between different roots + if ((FromI == FromS) && !sys::path::root_name(PathTo).empty()) + return PathTo.str(); + + SmallString<128> Relative; + for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI) + sys::path::append(Relative, sys::path::Style::posix, ".."); + + for (auto ToE = sys::path::end(PathTo); ToI != ToE; ++ToI) + sys::path::append(Relative, sys::path::Style::posix, *ToI); + + return Relative.str(); +} + +Error writeArchive(StringRef ArcName, ArrayRef NewMembers, + bool WriteSymtab, object::Archive::Kind Kind, + bool Deterministic, bool Thin, + std::unique_ptr OldArchiveBuf) { + assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode"); + + SmallString<0> SymNamesBuf; + raw_svector_ostream SymNames(SymNamesBuf); + SmallString<0> StringTableBuf; + raw_svector_ostream StringTable(StringTableBuf); + + Expected> DataOrErr = computeMemberData( + StringTable, SymNames, Kind, Thin, Deterministic, NewMembers); + if (Error E = DataOrErr.takeError()) + return E; + std::vector &Data = *DataOrErr; + + if (!StringTableBuf.empty()) + Data.insert(Data.begin(), computeStringTable(StringTableBuf)); + + // We would like to detect if we need to switch to a 64-bit symbol table. + if (WriteSymtab) { + uint64_t MaxOffset = 0; + uint64_t LastOffset = MaxOffset; + for (const auto &M : Data) { + // Record the start of the member's offset + LastOffset = MaxOffset; + // Account for the size of each part associated with the member. + MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size(); + // We assume 32-bit symbols to see if 32-bit symbols are possible or not. + MaxOffset += M.Symbols.size() * 4; + } + + // The SYM64 format is used when an archive's member offsets are larger than + // 32-bits can hold. The need for this shift in format is detected by + // writeArchive. To test this we need to generate a file with a member that + // has an offset larger than 32-bits but this demands a very slow test. To + // speed the test up we use this environment variable to pretend like the + // cutoff happens before 32-bits and instead happens at some much smaller + // value. + const char *Sym64Env = std::getenv("SYM64_THRESHOLD"); + int Sym64Threshold = 32; + if (Sym64Env) + StringRef(Sym64Env).getAsInteger(10, Sym64Threshold); + + // If LastOffset isn't going to fit in a 32-bit varible we need to switch + // to 64-bit. Note that the file can be larger than 4GB as long as the last + // member starts before the 4GB offset. + if (LastOffset >= (1ULL << Sym64Threshold)) { + if (Kind == object::Archive::K_DARWIN) + Kind = object::Archive::K_DARWIN64; + else + Kind = object::Archive::K_GNU64; + } + } + + Expected Temp = + sys::fs::TempFile::create(ArcName + ".temp-archive-%%%%%%%.a"); + if (!Temp) + return Temp.takeError(); + + raw_fd_ostream Out(Temp->FD, false); + if (Thin) + Out << "!\n"; + else + Out << "!\n"; + + if (WriteSymtab) + writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf); + + for (const MemberData &M : Data) + Out << M.Header << M.Data << M.Padding; + + Out.flush(); + + // At this point, we no longer need whatever backing memory + // was used to generate the NewMembers. On Windows, this buffer + // could be a mapped view of the file we want to replace (if + // we're updating an existing archive, say). In that case, the + // rename would still succeed, but it would leave behind a + // temporary file (actually the original file renamed) because + // a file cannot be deleted while there's a handle open on it, + // only renamed. So by freeing this buffer, this ensures that + // the last open handle on the destination file, if any, is + // closed before we attempt to rename. + OldArchiveBuf.reset(); + + return Temp->keep(ArcName); +} + +} // namespace llvm Index: test/tools/llvm-ar/reduce-thin-path.test =================================================================== --- test/tools/llvm-ar/reduce-thin-path.test +++ test/tools/llvm-ar/reduce-thin-path.test @@ -0,0 +1,10 @@ +RUN: rm -rf %t && mkdir -p %t/foo/bar/ +RUN: mkdir -p %t/baz/ +RUN: yaml2obj %S/Inputs/elf.yaml -o %t/elf.o + +RUN: cd %t && llvm-ar rTc %t/baz/internal.ar elf.o +RUN: cd %t/foo && llvm-ar rTc %t/foo/bar/external.ar ../baz/internal.ar + +RUN: FileCheck -input-file=%t/foo/bar/external.ar %s + +CHECK: {{^}}../../elf.o/ Index: test/tools/llvm-ar/thin-archive.test =================================================================== --- test/tools/llvm-ar/thin-archive.test +++ test/tools/llvm-ar/thin-archive.test @@ -0,0 +1,45 @@ +RUN: rm -rf %t && mkdir -p %t/foo/bar/ + +RUN: yaml2obj %S/Inputs/elf.yaml -o %t/foo/elf.o +RUN: cp %t/foo/elf.o %t/foo/bar/elf.o +RUN: cp %t/foo/bar/elf.o %t/delete.o + +Test that modules can be added with absolute paths when the archive is created using an absolute path + +RUN: llvm-ar rTc %t/absolute-1.ar %t/foo/elf.o %t/delete.o %t/foo/bar/elf.o +RUN: llvm-ar dT %t/absolute-1.ar delete.o + +RUN: FileCheck -input-file=%t/absolute-1.ar --check-prefixes=THIN,CHECK %s -DPATH=%/t/ +RUN: llvm-ar t %t/absolute-1.ar | FileCheck %s -DPATH=%/t/ + +Test that modules can be added with absolute paths when the archive is created using a relative path + +RUN: llvm-ar rTc Output/%basename_t.tmp/absolute-2.ar %t/foo/elf.o %t/delete.o %t/foo/bar/elf.o +RUN: llvm-ar dT Output/%basename_t.tmp/absolute-2.ar %t/delete.o + +RUN: FileCheck -input-file=%t/absolute-2.ar --check-prefixes=THIN,CHECK %s -DPATH=%/t/ +RUN: llvm-ar t %t/absolute-2.ar | FileCheck %s -DPATH=%/t/ + +These tests must be run in %t/foo. cd %t is included on each line to make debugging this test case easier. + +Test that modules can be added with relative paths when the archive is created using a relative path + +RUN: cd %t/foo && llvm-ar rTc ../relative-1.ar elf.o ../delete.o bar/elf.o +RUN: cd %t/foo && llvm-ar dT ../relative-1.ar delete.o + +RUN: FileCheck -input-file=%t/relative-1.ar --check-prefixes=THIN,CHECK %s -DPATH= +RUN: llvm-ar t %t/relative-1.ar | FileCheck %s -DPATH=%/t/ + +Test that modules can be added with relative paths when the archive is created using a absolute path + +RUN: cd %t/foo && llvm-ar rTc %t/relative-2.ar elf.o ../delete.o bar/elf.o +cd %t/foo && llvm-ar dT %t/relative-2.ar delete.o + +FileCheck -input-file=%t/relative-2.ar --check-prefixes=THIN,CHECK %s -DPATH= +llvm-ar t %t/relative-2.ar | FileCheck %s -DPATH=%/t/ + +THIN: ! + +CHECK-NOT: delete.o +CHECK: {{^}}[[PATH]]foo/elf.o +CHECK: {{^}}[[PATH]]foo/bar/elf.o \ No newline at end of file Index: tools/llvm-ar/llvm-ar.cpp =================================================================== --- tools/llvm-ar/llvm-ar.cpp +++ tools/llvm-ar/llvm-ar.cpp @@ -1,1078 +1,1096 @@ -//===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// Builds up (relatively) standard unix archive files (.a) containing LLVM -// bitcode or other files. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/StringSwitch.h" -#include "llvm/ADT/Triple.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/Object/Archive.h" -#include "llvm/Object/ArchiveWriter.h" -#include "llvm/Object/MachO.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Support/Chrono.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Format.h" -#include "llvm/Support/FormatVariadic.h" -#include "llvm/Support/InitLLVM.h" -#include "llvm/Support/LineIterator.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/Process.h" -#include "llvm/Support/StringSaver.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Support/ToolOutputFile.h" -#include "llvm/Support/WithColor.h" -#include "llvm/Support/raw_ostream.h" -#include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h" -#include "llvm/ToolDrivers/llvm-lib/LibDriver.h" - -#if !defined(_MSC_VER) && !defined(__MINGW32__) -#include -#else -#include -#endif - -using namespace llvm; - -// The name this program was invoked as. -static StringRef ToolName; - -// The basename of this program. -static StringRef Stem; - -const char RanlibHelp[] = R"( -OVERVIEW: LLVM Ranlib (llvm-ranlib) - - This program generates an index to speed access to archives - -USAGE: llvm-ranlib - -OPTIONS: - -help - Display available options - -version - Display the version of this program -)"; - -const char ArHelp[] = R"( -OVERVIEW: LLVM Archiver - -USAGE: llvm-ar [options] [-][modifiers] [relpos] [files] - llvm-ar -M [ - Ignored for compatibility - --help - Display available options - --version - Display the version of this program - -OPERATIONS: - d - delete [files] from the archive - m - move [files] in the archive - p - print [files] found in the archive - q - quick append [files] to the archive - r - replace or insert [files] into the archive - s - act as ranlib - t - display contents of archive - x - extract [files] from the archive - -MODIFIERS: - [a] - put [files] after [relpos] - [b] - put [files] before [relpos] (same as [i]) - [c] - do not warn if archive had to be created - [D] - use zero for timestamps and uids/gids (default) - [i] - put [files] before [relpos] (same as [b]) - [l] - ignored for compatibility - [L] - add archive's contents - [o] - preserve original dates - [P] - use full names when matching (implied for thin archives) - [s] - create an archive index (cf. ranlib) - [S] - do not build a symbol table - [T] - create a thin archive - [u] - update only [files] newer than archive contents - [U] - use actual timestamps and uids/gids - [v] - be verbose about actions taken -)"; - -void printHelpMessage() { - if (Stem.contains_lower("ranlib")) - outs() << RanlibHelp; - else if (Stem.contains_lower("ar")) - outs() << ArHelp; -} - -// Show the error message and exit. -LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) { - WithColor::error(errs(), ToolName) << Error << ".\n"; - printHelpMessage(); - exit(1); -} - -static void failIfError(std::error_code EC, Twine Context = "") { - if (!EC) - return; - - std::string ContextStr = Context.str(); - if (ContextStr.empty()) - fail(EC.message()); - fail(Context + ": " + EC.message()); -} - -static void failIfError(Error E, Twine Context = "") { - if (!E) - return; - - handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) { - std::string ContextStr = Context.str(); - if (ContextStr.empty()) - fail(EIB.message()); - fail(Context + ": " + EIB.message()); - }); -} - -static SmallVector PositionalArgs; - -static bool MRI; - -namespace { -enum Format { Default, GNU, BSD, DARWIN, Unknown }; -} - -static Format FormatType = Default; - -static std::string Options; - -// This enumeration delineates the kinds of operations on an archive -// that are permitted. -enum ArchiveOperation { - Print, ///< Print the contents of the archive - Delete, ///< Delete the specified members - Move, ///< Move members to end or as given by {a,b,i} modifiers - QuickAppend, ///< Quickly append to end of archive - ReplaceOrInsert, ///< Replace or Insert members - DisplayTable, ///< Display the table of contents - Extract, ///< Extract files back to file system - CreateSymTab ///< Create a symbol table in an existing archive -}; - -// Modifiers to follow operation to vary behavior -static bool AddAfter = false; ///< 'a' modifier -static bool AddBefore = false; ///< 'b' modifier -static bool Create = false; ///< 'c' modifier -static bool OriginalDates = false; ///< 'o' modifier -static bool CompareFullPath = false; ///< 'P' modifier -static bool OnlyUpdate = false; ///< 'u' modifier -static bool Verbose = false; ///< 'v' modifier -static bool Symtab = true; ///< 's' modifier -static bool Deterministic = true; ///< 'D' and 'U' modifiers -static bool Thin = false; ///< 'T' modifier -static bool AddLibrary = false; ///< 'L' modifier - -// Relative Positional Argument (for insert/move). This variable holds -// the name of the archive member to which the 'a', 'b' or 'i' modifier -// refers. Only one of 'a', 'b' or 'i' can be specified so we only need -// one variable. -static std::string RelPos; - -// This variable holds the name of the archive file as given on the -// command line. -static std::string ArchiveName; - -// This variable holds the list of member files to proecess, as given -// on the command line. -static std::vector Members; - -// Static buffer to hold StringRefs. -static BumpPtrAllocator Alloc; - -// Extract the member filename from the command line for the [relpos] argument -// associated with a, b, and i modifiers -static void getRelPos() { - if (PositionalArgs.empty()) - fail("Expected [relpos] for a, b, or i modifier"); - RelPos = PositionalArgs[0]; - PositionalArgs.erase(PositionalArgs.begin()); -} - -// Get the archive file name from the command line -static void getArchive() { - if (PositionalArgs.empty()) - fail("An archive name must be specified"); - ArchiveName = PositionalArgs[0]; - PositionalArgs.erase(PositionalArgs.begin()); -} - -// Copy over remaining items in PositionalArgs to our Members vector -static void getMembers() { - for (auto &Arg : PositionalArgs) - Members.push_back(Arg); -} - -std::vector> ArchiveBuffers; -std::vector> Archives; - -static object::Archive &readLibrary(const Twine &Library) { - auto BufOrErr = MemoryBuffer::getFile(Library, -1, false); - failIfError(BufOrErr.getError(), "Could not open library " + Library); - ArchiveBuffers.push_back(std::move(*BufOrErr)); - auto LibOrErr = - object::Archive::create(ArchiveBuffers.back()->getMemBufferRef()); - failIfError(errorToErrorCode(LibOrErr.takeError()), - "Could not parse library"); - Archives.push_back(std::move(*LibOrErr)); - return *Archives.back(); -} - -static void runMRIScript(); - -// Parse the command line options as presented and return the operation -// specified. Process all modifiers and check to make sure that constraints on -// modifier/operation pairs have not been violated. -static ArchiveOperation parseCommandLine() { - if (MRI) { - if (!PositionalArgs.empty() || !Options.empty()) - fail("Cannot mix -M and other options"); - runMRIScript(); - } - - // Keep track of number of operations. We can only specify one - // per execution. - unsigned NumOperations = 0; - - // Keep track of the number of positional modifiers (a,b,i). Only - // one can be specified. - unsigned NumPositional = 0; - - // Keep track of which operation was requested - ArchiveOperation Operation; - - bool MaybeJustCreateSymTab = false; - - for (unsigned i = 0; i < Options.size(); ++i) { - switch (Options[i]) { - case 'd': - ++NumOperations; - Operation = Delete; - break; - case 'm': - ++NumOperations; - Operation = Move; - break; - case 'p': - ++NumOperations; - Operation = Print; - break; - case 'q': - ++NumOperations; - Operation = QuickAppend; - break; - case 'r': - ++NumOperations; - Operation = ReplaceOrInsert; - break; - case 't': - ++NumOperations; - Operation = DisplayTable; - break; - case 'x': - ++NumOperations; - Operation = Extract; - break; - case 'c': - Create = true; - break; - case 'l': /* accepted but unused */ - break; - case 'o': - OriginalDates = true; - break; - case 'P': - CompareFullPath = true; - break; - case 's': - Symtab = true; - MaybeJustCreateSymTab = true; - break; - case 'S': - Symtab = false; - break; - case 'u': - OnlyUpdate = true; - break; - case 'v': - Verbose = true; - break; - case 'a': - getRelPos(); - AddAfter = true; - NumPositional++; - break; - case 'b': - getRelPos(); - AddBefore = true; - NumPositional++; - break; - case 'i': - getRelPos(); - AddBefore = true; - NumPositional++; - break; - case 'D': - Deterministic = true; - break; - case 'U': - Deterministic = false; - break; - case 'T': - Thin = true; - // Thin archives store path names, so P should be forced. - CompareFullPath = true; - break; - case 'L': - AddLibrary = true; - break; - default: - fail(std::string("unknown option ") + Options[i]); - } - } - - // At this point, the next thing on the command line must be - // the archive name. - getArchive(); - - // Everything on the command line at this point is a member. - getMembers(); - - if (NumOperations == 0 && MaybeJustCreateSymTab) { - NumOperations = 1; - Operation = CreateSymTab; - if (!Members.empty()) - fail("The s operation takes only an archive as argument"); - } - - // Perform various checks on the operation/modifier specification - // to make sure we are dealing with a legal request. - if (NumOperations == 0) - fail("You must specify at least one of the operations"); - if (NumOperations > 1) - fail("Only one operation may be specified"); - if (NumPositional > 1) - fail("You may only specify one of a, b, and i modifiers"); - if (AddAfter || AddBefore) { - if (Operation != Move && Operation != ReplaceOrInsert) - fail("The 'a', 'b' and 'i' modifiers can only be specified with " - "the 'm' or 'r' operations"); - } - if (OriginalDates && Operation != Extract) - fail("The 'o' modifier is only applicable to the 'x' operation"); - if (OnlyUpdate && Operation != ReplaceOrInsert) - fail("The 'u' modifier is only applicable to the 'r' operation"); - if (AddLibrary && Operation != QuickAppend) - fail("The 'L' modifier is only applicable to the 'q' operation"); - - // Return the parsed operation to the caller - return Operation; -} - -// Implements the 'p' operation. This function traverses the archive -// looking for members that match the path list. -static void doPrint(StringRef Name, const object::Archive::Child &C) { - if (Verbose) - outs() << "Printing " << Name << "\n"; - - Expected DataOrErr = C.getBuffer(); - failIfError(DataOrErr.takeError()); - StringRef Data = *DataOrErr; - outs().write(Data.data(), Data.size()); -} - -// Utility function for printing out the file mode when the 't' operation is in -// verbose mode. -static void printMode(unsigned mode) { - outs() << ((mode & 004) ? "r" : "-"); - outs() << ((mode & 002) ? "w" : "-"); - outs() << ((mode & 001) ? "x" : "-"); -} - -// Implement the 't' operation. This function prints out just -// the file names of each of the members. However, if verbose mode is requested -// ('v' modifier) then the file type, permission mode, user, group, size, and -// modification time are also printed. -static void doDisplayTable(StringRef Name, const object::Archive::Child &C) { - if (Verbose) { - Expected ModeOrErr = C.getAccessMode(); - failIfError(ModeOrErr.takeError()); - sys::fs::perms Mode = ModeOrErr.get(); - printMode((Mode >> 6) & 007); - printMode((Mode >> 3) & 007); - printMode(Mode & 007); - Expected UIDOrErr = C.getUID(); - failIfError(UIDOrErr.takeError()); - outs() << ' ' << UIDOrErr.get(); - Expected GIDOrErr = C.getGID(); - failIfError(GIDOrErr.takeError()); - outs() << '/' << GIDOrErr.get(); - Expected Size = C.getSize(); - failIfError(Size.takeError()); - outs() << ' ' << format("%6llu", Size.get()); - auto ModTimeOrErr = C.getLastModified(); - failIfError(ModTimeOrErr.takeError()); - // Note: formatv() only handles the default TimePoint<>, which is in - // nanoseconds. - // TODO: fix format_provider> to allow other units. - sys::TimePoint<> ModTimeInNs = ModTimeOrErr.get(); - outs() << ' ' << formatv("{0:%b %e %H:%M %Y}", ModTimeInNs); - outs() << ' '; - } - - if (C.getParent()->isThin()) { - StringRef ParentDir = sys::path::parent_path(ArchiveName); - if (!ParentDir.empty()) - outs() << ParentDir << '/'; - } - outs() << Name << "\n"; -} - -static StringRef normalizePath(StringRef Path) { - return CompareFullPath ? Path : sys::path::filename(Path); -} - -// Implement the 'x' operation. This function extracts files back to the file -// system. -static void doExtract(StringRef Name, const object::Archive::Child &C) { - // Retain the original mode. - Expected ModeOrErr = C.getAccessMode(); - failIfError(ModeOrErr.takeError()); - sys::fs::perms Mode = ModeOrErr.get(); - - int FD; - failIfError(sys::fs::openFileForWrite(sys::path::filename(Name), FD, - sys::fs::CD_CreateAlways, - sys::fs::F_None, Mode), - Name); - - { - raw_fd_ostream file(FD, false); - - // Get the data and its length - Expected BufOrErr = C.getBuffer(); - failIfError(BufOrErr.takeError()); - StringRef Data = BufOrErr.get(); - - // Write the data. - file.write(Data.data(), Data.size()); - } - - // If we're supposed to retain the original modification times, etc. do so - // now. - if (OriginalDates) { - auto ModTimeOrErr = C.getLastModified(); - failIfError(ModTimeOrErr.takeError()); - failIfError( - sys::fs::setLastAccessAndModificationTime(FD, ModTimeOrErr.get())); - } - - if (close(FD)) - fail("Could not close the file"); -} - -static bool shouldCreateArchive(ArchiveOperation Op) { - switch (Op) { - case Print: - case Delete: - case Move: - case DisplayTable: - case Extract: - case CreateSymTab: - return false; - - case QuickAppend: - case ReplaceOrInsert: - return true; - } - - llvm_unreachable("Missing entry in covered switch."); -} - -static void performReadOperation(ArchiveOperation Operation, - object::Archive *OldArchive) { - if (Operation == Extract && OldArchive->isThin()) - fail("extracting from a thin archive is not supported"); - - bool Filter = !Members.empty(); - { - Error Err = Error::success(); - for (auto &C : OldArchive->children(Err)) { - Expected NameOrErr = C.getName(); - failIfError(NameOrErr.takeError()); - StringRef Name = NameOrErr.get(); - - if (Filter) { - auto I = find_if(Members, [Name](StringRef Path) { - return Name == normalizePath(Path); - }); - if (I == Members.end()) - continue; - Members.erase(I); - } - - switch (Operation) { - default: - llvm_unreachable("Not a read operation"); - case Print: - doPrint(Name, C); - break; - case DisplayTable: - doDisplayTable(Name, C); - break; - case Extract: - doExtract(Name, C); - break; - } - } - failIfError(std::move(Err)); - } - - if (Members.empty()) - return; - for (StringRef Name : Members) - WithColor::error(errs(), ToolName) << "'" << Name << "' was not found\n"; - exit(1); -} - -static void addChildMember(std::vector &Members, - const object::Archive::Child &M, - bool FlattenArchive = false) { - if (Thin && !M.getParent()->isThin()) - fail("Cannot convert a regular archive to a thin one"); - Expected NMOrErr = - NewArchiveMember::getOldMember(M, Deterministic); - failIfError(NMOrErr.takeError()); - // If the child member we're trying to add is thin, use the path relative to - // the archive it's in, so the file resolves correctly. - if (Thin && FlattenArchive) { - StringSaver Saver(Alloc); - Expected FileNameOrErr = M.getFullName(); - failIfError(FileNameOrErr.takeError()); - NMOrErr->MemberName = - Saver.save(computeArchiveRelativePath(ArchiveName, *FileNameOrErr)); - } - if (FlattenArchive && - identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) { - Expected FileNameOrErr = M.getFullName(); - failIfError(FileNameOrErr.takeError()); - object::Archive &Lib = readLibrary(*FileNameOrErr); - // When creating thin archives, only flatten if the member is also thin. - if (!Thin || Lib.isThin()) { - Error Err = Error::success(); - // Only Thin archives are recursively flattened. - for (auto &Child : Lib.children(Err)) - addChildMember(Members, Child, /*FlattenArchive=*/Thin); - failIfError(std::move(Err)); - return; - } - } - Members.push_back(std::move(*NMOrErr)); -} - -static void addMember(std::vector &Members, - StringRef FileName, bool FlattenArchive = false) { - Expected NMOrErr = - NewArchiveMember::getFile(FileName, Deterministic); - failIfError(NMOrErr.takeError(), FileName); - StringSaver Saver(Alloc); - // For regular archives, use the basename of the object path for the member - // name. For thin archives, use the full relative paths so the file resolves - // correctly. - NMOrErr->MemberName = - Thin ? Saver.save(computeArchiveRelativePath(ArchiveName, FileName)) - : sys::path::filename(NMOrErr->MemberName); - if (FlattenArchive && - identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) { - object::Archive &Lib = readLibrary(FileName); - // When creating thin archives, only flatten if the member is also thin. - if (!Thin || Lib.isThin()) { - Error Err = Error::success(); - // Only Thin archives are recursively flattened. - for (auto &Child : Lib.children(Err)) - addChildMember(Members, Child, /*FlattenArchive=*/Thin); - failIfError(std::move(Err)); - return; - } - } - Members.push_back(std::move(*NMOrErr)); -} - -enum InsertAction { - IA_AddOldMember, - IA_AddNewMember, - IA_Delete, - IA_MoveOldMember, - IA_MoveNewMember -}; - -static InsertAction computeInsertAction(ArchiveOperation Operation, - const object::Archive::Child &Member, - StringRef Name, - std::vector::iterator &Pos) { - if (Operation == QuickAppend || Members.empty()) - return IA_AddOldMember; - - auto MI = find_if( - Members, [Name](StringRef Path) { return Name == normalizePath(Path); }); - - if (MI == Members.end()) - return IA_AddOldMember; - - Pos = MI; - - if (Operation == Delete) - return IA_Delete; - - if (Operation == Move) - return IA_MoveOldMember; - - if (Operation == ReplaceOrInsert) { - StringRef PosName = normalizePath(RelPos); - if (!OnlyUpdate) { - if (PosName.empty()) - return IA_AddNewMember; - return IA_MoveNewMember; - } - - // We could try to optimize this to a fstat, but it is not a common - // operation. - sys::fs::file_status Status; - failIfError(sys::fs::status(*MI, Status), *MI); - auto ModTimeOrErr = Member.getLastModified(); - failIfError(ModTimeOrErr.takeError()); - if (Status.getLastModificationTime() < ModTimeOrErr.get()) { - if (PosName.empty()) - return IA_AddOldMember; - return IA_MoveOldMember; - } - - if (PosName.empty()) - return IA_AddNewMember; - return IA_MoveNewMember; - } - llvm_unreachable("No such operation"); -} - -// We have to walk this twice and computing it is not trivial, so creating an -// explicit std::vector is actually fairly efficient. -static std::vector -computeNewArchiveMembers(ArchiveOperation Operation, - object::Archive *OldArchive) { - std::vector Ret; - std::vector Moved; - int InsertPos = -1; - StringRef PosName = normalizePath(RelPos); - if (OldArchive) { - Error Err = Error::success(); - for (auto &Child : OldArchive->children(Err)) { - int Pos = Ret.size(); - Expected NameOrErr = Child.getName(); - failIfError(NameOrErr.takeError()); - StringRef Name = NameOrErr.get(); - if (Name == PosName) { - assert(AddAfter || AddBefore); - if (AddBefore) - InsertPos = Pos; - else - InsertPos = Pos + 1; - } - - std::vector::iterator MemberI = Members.end(); - InsertAction Action = - computeInsertAction(Operation, Child, Name, MemberI); - switch (Action) { - case IA_AddOldMember: - addChildMember(Ret, Child, /*FlattenArchive=*/Thin); - break; - case IA_AddNewMember: - addMember(Ret, *MemberI); - break; - case IA_Delete: - break; - case IA_MoveOldMember: - addChildMember(Moved, Child, /*FlattenArchive=*/Thin); - break; - case IA_MoveNewMember: - addMember(Moved, *MemberI); - break; - } - if (MemberI != Members.end()) - Members.erase(MemberI); - } - failIfError(std::move(Err)); - } - - if (Operation == Delete) - return Ret; - - if (!RelPos.empty() && InsertPos == -1) - fail("Insertion point not found"); - - if (RelPos.empty()) - InsertPos = Ret.size(); - - assert(unsigned(InsertPos) <= Ret.size()); - int Pos = InsertPos; - for (auto &M : Moved) { - Ret.insert(Ret.begin() + Pos, std::move(M)); - ++Pos; - } - - if (AddLibrary) { - assert(Operation == QuickAppend); - for (auto &Member : Members) - addMember(Ret, Member, /*FlattenArchive=*/true); - return Ret; - } - - std::vector NewMembers; - for (auto &Member : Members) - addMember(NewMembers, Member, /*FlattenArchive=*/Thin); - Ret.reserve(Ret.size() + NewMembers.size()); - std::move(NewMembers.begin(), NewMembers.end(), - std::inserter(Ret, std::next(Ret.begin(), InsertPos))); - - return Ret; -} - -static object::Archive::Kind getDefaultForHost() { - return Triple(sys::getProcessTriple()).isOSDarwin() - ? object::Archive::K_DARWIN - : object::Archive::K_GNU; -} - -static object::Archive::Kind getKindFromMember(const NewArchiveMember &Member) { - Expected> OptionalObject = - object::ObjectFile::createObjectFile(Member.Buf->getMemBufferRef()); - - if (OptionalObject) - return isa(**OptionalObject) - ? object::Archive::K_DARWIN - : object::Archive::K_GNU; - - // squelch the error in case we had a non-object file - consumeError(OptionalObject.takeError()); - return getDefaultForHost(); -} - -static void performWriteOperation(ArchiveOperation Operation, - object::Archive *OldArchive, - std::unique_ptr OldArchiveBuf, - std::vector *NewMembersP) { - std::vector NewMembers; - if (!NewMembersP) - NewMembers = computeNewArchiveMembers(Operation, OldArchive); - - object::Archive::Kind Kind; - switch (FormatType) { - case Default: - if (Thin) - Kind = object::Archive::K_GNU; - else if (OldArchive) - Kind = OldArchive->kind(); - else if (NewMembersP) - Kind = !NewMembersP->empty() ? getKindFromMember(NewMembersP->front()) - : getDefaultForHost(); - else - Kind = !NewMembers.empty() ? getKindFromMember(NewMembers.front()) - : getDefaultForHost(); - break; - case GNU: - Kind = object::Archive::K_GNU; - break; - case BSD: - if (Thin) - fail("Only the gnu format has a thin mode"); - Kind = object::Archive::K_BSD; - break; - case DARWIN: - if (Thin) - fail("Only the gnu format has a thin mode"); - Kind = object::Archive::K_DARWIN; - break; - case Unknown: - llvm_unreachable(""); - } - - Error E = - writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab, - Kind, Deterministic, Thin, std::move(OldArchiveBuf)); - failIfError(std::move(E), ArchiveName); -} - -static void createSymbolTable(object::Archive *OldArchive) { - // When an archive is created or modified, if the s option is given, the - // resulting archive will have a current symbol table. If the S option - // is given, it will have no symbol table. - // In summary, we only need to update the symbol table if we have none. - // This is actually very common because of broken build systems that think - // they have to run ranlib. - if (OldArchive->hasSymbolTable()) - return; - - performWriteOperation(CreateSymTab, OldArchive, nullptr, nullptr); -} - -static void performOperation(ArchiveOperation Operation, - object::Archive *OldArchive, - std::unique_ptr OldArchiveBuf, - std::vector *NewMembers) { - switch (Operation) { - case Print: - case DisplayTable: - case Extract: - performReadOperation(Operation, OldArchive); - return; - - case Delete: - case Move: - case QuickAppend: - case ReplaceOrInsert: - performWriteOperation(Operation, OldArchive, std::move(OldArchiveBuf), - NewMembers); - return; - case CreateSymTab: - createSymbolTable(OldArchive); - return; - } - llvm_unreachable("Unknown operation."); -} - -static int performOperation(ArchiveOperation Operation, - std::vector *NewMembers) { - // Create or open the archive object. - ErrorOr> Buf = - MemoryBuffer::getFile(ArchiveName, -1, false); - std::error_code EC = Buf.getError(); - if (EC && EC != errc::no_such_file_or_directory) - fail("error opening '" + ArchiveName + "': " + EC.message() + "!"); - - if (!EC) { - Error Err = Error::success(); - object::Archive Archive(Buf.get()->getMemBufferRef(), Err); - EC = errorToErrorCode(std::move(Err)); - failIfError(EC, - "error loading '" + ArchiveName + "': " + EC.message() + "!"); - if (Archive.isThin()) - CompareFullPath = true; - performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers); - return 0; - } - - assert(EC == errc::no_such_file_or_directory); - - if (!shouldCreateArchive(Operation)) { - failIfError(EC, Twine("error loading '") + ArchiveName + "'"); - } else { - if (!Create) { - // Produce a warning if we should and we're creating the archive - WithColor::warning(errs(), ToolName) - << "creating " << ArchiveName << "\n"; - } - } - - performOperation(Operation, nullptr, nullptr, NewMembers); - return 0; -} - -static void runMRIScript() { - enum class MRICommand { AddLib, AddMod, Create, Delete, Save, End, Invalid }; - - ErrorOr> Buf = MemoryBuffer::getSTDIN(); - failIfError(Buf.getError()); - const MemoryBuffer &Ref = *Buf.get(); - bool Saved = false; - std::vector NewMembers; - - for (line_iterator I(Ref, /*SkipBlanks*/ false), E; I != E; ++I) { - StringRef Line = *I; - Line = Line.split(';').first; - Line = Line.split('*').first; - Line = Line.trim(); - if (Line.empty()) - continue; - StringRef CommandStr, Rest; - std::tie(CommandStr, Rest) = Line.split(' '); - Rest = Rest.trim(); - if (!Rest.empty() && Rest.front() == '"' && Rest.back() == '"') - Rest = Rest.drop_front().drop_back(); - auto Command = StringSwitch(CommandStr.lower()) - .Case("addlib", MRICommand::AddLib) - .Case("addmod", MRICommand::AddMod) - .Case("create", MRICommand::Create) - .Case("delete", MRICommand::Delete) - .Case("save", MRICommand::Save) - .Case("end", MRICommand::End) - .Default(MRICommand::Invalid); - - switch (Command) { - case MRICommand::AddLib: { - object::Archive &Lib = readLibrary(Rest); - { - Error Err = Error::success(); - for (auto &Member : Lib.children(Err)) - addChildMember(NewMembers, Member, /*FlattenArchive=*/Thin); - failIfError(std::move(Err)); - } - break; - } - case MRICommand::AddMod: - addMember(NewMembers, Rest); - break; - case MRICommand::Create: - Create = true; - if (!ArchiveName.empty()) - fail("Editing multiple archives not supported"); - if (Saved) - fail("File already saved"); - ArchiveName = Rest; - break; - case MRICommand::Delete: { - StringRef Name = normalizePath(Rest); - llvm::erase_if(NewMembers, - [=](NewArchiveMember &M) { return M.MemberName == Name; }); - break; - } - case MRICommand::Save: - Saved = true; - break; - case MRICommand::End: - break; - case MRICommand::Invalid: - fail("Unknown command: " + CommandStr); - } - } - - // Nothing to do if not saved. - if (Saved) - performOperation(ReplaceOrInsert, &NewMembers); - exit(0); -} - -static bool handleGenericOption(StringRef arg) { - if (arg == "-help" || arg == "--help") { - printHelpMessage(); - return true; - } - if (arg == "-version" || arg == "--version") { - cl::PrintVersionMessage(); - return true; - } - return false; -} - -static int ar_main(int argc, char **argv) { - SmallVector Argv(argv, argv + argc); - StringSaver Saver(Alloc); - cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv); - for (size_t i = 1; i < Argv.size(); ++i) { - StringRef Arg = Argv[i]; - const char *match; - auto MatchFlagWithArg = [&](const char *expected) { - size_t len = strlen(expected); - if (Arg == expected) { - if (++i >= Argv.size()) - fail(std::string(expected) + " requires an argument"); - match = Argv[i]; - return true; - } - if (Arg.startswith(expected) && Arg.size() > len && Arg[len] == '=') { - match = Arg.data() + len + 1; - return true; - } - return false; - }; - if (handleGenericOption(Argv[i])) - return 0; - if (Arg == "--") { - for (; i < Argv.size(); ++i) - PositionalArgs.push_back(Argv[i]); - break; - } - if (Arg[0] == '-') { - if (Arg.startswith("--")) - Arg = Argv[i] + 2; - else - Arg = Argv[i] + 1; - if (Arg == "M") { - MRI = true; - } else if (MatchFlagWithArg("format")) { - FormatType = StringSwitch(match) - .Case("default", Default) - .Case("gnu", GNU) - .Case("darwin", DARWIN) - .Case("bsd", BSD) - .Default(Unknown); - if (FormatType == Unknown) - fail(std::string("Invalid format ") + match); - } else if (MatchFlagWithArg("plugin")) { - // Ignored. - } else { - Options += Argv[i] + 1; - } - } else if (Options.empty()) { - Options += Argv[i]; - } else { - PositionalArgs.push_back(Argv[i]); - } - } - ArchiveOperation Operation = parseCommandLine(); - return performOperation(Operation, nullptr); -} - -static int ranlib_main(int argc, char **argv) { - bool ArchiveSpecified = false; - for (int i = 1; i < argc; ++i) { - if (handleGenericOption(argv[i])) { - return 0; - } else { - if (ArchiveSpecified) - fail("Exactly one archive should be specified"); - ArchiveSpecified = true; - ArchiveName = argv[i]; - } - } - return performOperation(CreateSymTab, nullptr); -} - -int main(int argc, char **argv) { - InitLLVM X(argc, argv); - ToolName = argv[0]; - - llvm::InitializeAllTargetInfos(); - llvm::InitializeAllTargetMCs(); - llvm::InitializeAllAsmParsers(); - - Stem = sys::path::stem(ToolName); - if (Stem.contains_lower("dlltool")) - return dlltoolDriverMain(makeArrayRef(argv, argc)); - - if (Stem.contains_lower("ranlib")) - return ranlib_main(argc, argv); - - if (Stem.contains_lower("lib")) - return libDriverMain(makeArrayRef(argv, argc)); - - if (Stem.contains_lower("ar")) - return ar_main(argc, argv); - fail("Not ranlib, ar, lib or dlltool!"); -} +//===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// Builds up (relatively) standard unix archive files (.a) containing LLVM +// bitcode or other files. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/StringSwitch.h" +#include "llvm/ADT/Triple.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/Object/Archive.h" +#include "llvm/Object/ArchiveWriter.h" +#include "llvm/Object/MachO.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Support/Chrono.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Errc.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Format.h" +#include "llvm/Support/FormatVariadic.h" +#include "llvm/Support/InitLLVM.h" +#include "llvm/Support/LineIterator.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/Process.h" +#include "llvm/Support/StringSaver.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Support/WithColor.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h" +#include "llvm/ToolDrivers/llvm-lib/LibDriver.h" + +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#else +#include +#endif + +using namespace llvm; + +// The name this program was invoked as. +static StringRef ToolName; + +// The basename of this program. +static StringRef Stem; + +const char RanlibHelp[] = R"( +OVERVIEW: LLVM Ranlib (llvm-ranlib) + + This program generates an index to speed access to archives + +USAGE: llvm-ranlib + +OPTIONS: + -help - Display available options + -version - Display the version of this program +)"; + +const char ArHelp[] = R"( +OVERVIEW: LLVM Archiver + +USAGE: llvm-ar [options] [-][modifiers] [relpos] [files] + llvm-ar -M [ - Ignored for compatibility + --help - Display available options + --version - Display the version of this program + +OPERATIONS: + d - delete [files] from the archive + m - move [files] in the archive + p - print [files] found in the archive + q - quick append [files] to the archive + r - replace or insert [files] into the archive + s - act as ranlib + t - display contents of archive + x - extract [files] from the archive + +MODIFIERS: + [a] - put [files] after [relpos] + [b] - put [files] before [relpos] (same as [i]) + [c] - do not warn if archive had to be created + [D] - use zero for timestamps and uids/gids (default) + [i] - put [files] before [relpos] (same as [b]) + [l] - ignored for compatibility + [L] - add archive's contents + [o] - preserve original dates + [P] - use full names when matching (implied for thin archives) + [s] - create an archive index (cf. ranlib) + [S] - do not build a symbol table + [T] - create a thin archive + [u] - update only [files] newer than archive contents + [U] - use actual timestamps and uids/gids + [v] - be verbose about actions taken +)"; + +void printHelpMessage() { + if (Stem.contains_lower("ranlib")) + outs() << RanlibHelp; + else if (Stem.contains_lower("ar")) + outs() << ArHelp; +} + +// Show the error message and exit. +LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) { + WithColor::error(errs(), ToolName) << Error << ".\n"; + printHelpMessage(); + exit(1); +} + +static void failIfError(std::error_code EC, Twine Context = "") { + if (!EC) + return; + + std::string ContextStr = Context.str(); + if (ContextStr.empty()) + fail(EC.message()); + fail(Context + ": " + EC.message()); +} + +static void failIfError(Error E, Twine Context = "") { + if (!E) + return; + + handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) { + std::string ContextStr = Context.str(); + if (ContextStr.empty()) + fail(EIB.message()); + fail(Context + ": " + EIB.message()); + }); +} + +static SmallVector PositionalArgs; + +static bool MRI; + +namespace { +enum Format { Default, GNU, BSD, DARWIN, Unknown }; +} + +static Format FormatType = Default; + +static std::string Options; + +// This enumeration delineates the kinds of operations on an archive +// that are permitted. +enum ArchiveOperation { + Print, ///< Print the contents of the archive + Delete, ///< Delete the specified members + Move, ///< Move members to end or as given by {a,b,i} modifiers + QuickAppend, ///< Quickly append to end of archive + ReplaceOrInsert, ///< Replace or Insert members + DisplayTable, ///< Display the table of contents + Extract, ///< Extract files back to file system + CreateSymTab ///< Create a symbol table in an existing archive +}; + +// Modifiers to follow operation to vary behavior +static bool AddAfter = false; ///< 'a' modifier +static bool AddBefore = false; ///< 'b' modifier +static bool Create = false; ///< 'c' modifier +static bool OriginalDates = false; ///< 'o' modifier +static bool CompareFullPath = false; ///< 'P' modifier +static bool OnlyUpdate = false; ///< 'u' modifier +static bool Verbose = false; ///< 'v' modifier +static bool Symtab = true; ///< 's' modifier +static bool Deterministic = true; ///< 'D' and 'U' modifiers +static bool Thin = false; ///< 'T' modifier +static bool AddLibrary = false; ///< 'L' modifier + +// Relative Positional Argument (for insert/move). This variable holds +// the name of the archive member to which the 'a', 'b' or 'i' modifier +// refers. Only one of 'a', 'b' or 'i' can be specified so we only need +// one variable. +static std::string RelPos; + +// This variable holds the name of the archive file as given on the +// command line. +static std::string ArchiveName; + +// This variable holds the list of member files to proecess, as given +// on the command line. +static std::vector Members; + +// Static buffer to hold StringRefs. +static BumpPtrAllocator Alloc; + +// Extract the member filename from the command line for the [relpos] argument +// associated with a, b, and i modifiers +static void getRelPos() { + if (PositionalArgs.empty()) + fail("Expected [relpos] for a, b, or i modifier"); + RelPos = PositionalArgs[0]; + PositionalArgs.erase(PositionalArgs.begin()); +} + +// Get the archive file name from the command line +static void getArchive() { + if (PositionalArgs.empty()) + fail("An archive name must be specified"); + ArchiveName = PositionalArgs[0]; + PositionalArgs.erase(PositionalArgs.begin()); +} + +// Copy over remaining items in PositionalArgs to our Members vector +static void getMembers() { + for (auto &Arg : PositionalArgs) + Members.push_back(Arg); +} + +std::vector> ArchiveBuffers; +std::vector> Archives; + +static object::Archive &readLibrary(const Twine &Library) { + auto BufOrErr = MemoryBuffer::getFile(Library, -1, false); + failIfError(BufOrErr.getError(), "Could not open library " + Library); + ArchiveBuffers.push_back(std::move(*BufOrErr)); + auto LibOrErr = + object::Archive::create(ArchiveBuffers.back()->getMemBufferRef()); + failIfError(errorToErrorCode(LibOrErr.takeError()), + "Could not parse library"); + Archives.push_back(std::move(*LibOrErr)); + return *Archives.back(); +} + +static void runMRIScript(); + +// Parse the command line options as presented and return the operation +// specified. Process all modifiers and check to make sure that constraints on +// modifier/operation pairs have not been violated. +static ArchiveOperation parseCommandLine() { + if (MRI) { + if (!PositionalArgs.empty() || !Options.empty()) + fail("Cannot mix -M and other options"); + runMRIScript(); + } + + // Keep track of number of operations. We can only specify one + // per execution. + unsigned NumOperations = 0; + + // Keep track of the number of positional modifiers (a,b,i). Only + // one can be specified. + unsigned NumPositional = 0; + + // Keep track of which operation was requested + ArchiveOperation Operation; + + bool MaybeJustCreateSymTab = false; + + for (unsigned i = 0; i < Options.size(); ++i) { + switch (Options[i]) { + case 'd': + ++NumOperations; + Operation = Delete; + break; + case 'm': + ++NumOperations; + Operation = Move; + break; + case 'p': + ++NumOperations; + Operation = Print; + break; + case 'q': + ++NumOperations; + Operation = QuickAppend; + break; + case 'r': + ++NumOperations; + Operation = ReplaceOrInsert; + break; + case 't': + ++NumOperations; + Operation = DisplayTable; + break; + case 'x': + ++NumOperations; + Operation = Extract; + break; + case 'c': + Create = true; + break; + case 'l': /* accepted but unused */ + break; + case 'o': + OriginalDates = true; + break; + case 'P': + CompareFullPath = true; + break; + case 's': + Symtab = true; + MaybeJustCreateSymTab = true; + break; + case 'S': + Symtab = false; + break; + case 'u': + OnlyUpdate = true; + break; + case 'v': + Verbose = true; + break; + case 'a': + getRelPos(); + AddAfter = true; + NumPositional++; + break; + case 'b': + getRelPos(); + AddBefore = true; + NumPositional++; + break; + case 'i': + getRelPos(); + AddBefore = true; + NumPositional++; + break; + case 'D': + Deterministic = true; + break; + case 'U': + Deterministic = false; + break; + case 'T': + Thin = true; + // Thin archives store path names, so P should be forced. + CompareFullPath = true; + break; + case 'L': + AddLibrary = true; + break; + default: + fail(std::string("unknown option ") + Options[i]); + } + } + + // At this point, the next thing on the command line must be + // the archive name. + getArchive(); + + // Everything on the command line at this point is a member. + getMembers(); + + if (NumOperations == 0 && MaybeJustCreateSymTab) { + NumOperations = 1; + Operation = CreateSymTab; + if (!Members.empty()) + fail("The s operation takes only an archive as argument"); + } + + // Perform various checks on the operation/modifier specification + // to make sure we are dealing with a legal request. + if (NumOperations == 0) + fail("You must specify at least one of the operations"); + if (NumOperations > 1) + fail("Only one operation may be specified"); + if (NumPositional > 1) + fail("You may only specify one of a, b, and i modifiers"); + if (AddAfter || AddBefore) { + if (Operation != Move && Operation != ReplaceOrInsert) + fail("The 'a', 'b' and 'i' modifiers can only be specified with " + "the 'm' or 'r' operations"); + } + if (OriginalDates && Operation != Extract) + fail("The 'o' modifier is only applicable to the 'x' operation"); + if (OnlyUpdate && Operation != ReplaceOrInsert) + fail("The 'u' modifier is only applicable to the 'r' operation"); + if (AddLibrary && Operation != QuickAppend) + fail("The 'L' modifier is only applicable to the 'q' operation"); + + // Return the parsed operation to the caller + return Operation; +} + +// Implements the 'p' operation. This function traverses the archive +// looking for members that match the path list. +static void doPrint(StringRef Name, const object::Archive::Child &C) { + if (Verbose) + outs() << "Printing " << Name << "\n"; + + Expected DataOrErr = C.getBuffer(); + failIfError(DataOrErr.takeError()); + StringRef Data = *DataOrErr; + outs().write(Data.data(), Data.size()); +} + +// Utility function for printing out the file mode when the 't' operation is in +// verbose mode. +static void printMode(unsigned mode) { + outs() << ((mode & 004) ? "r" : "-"); + outs() << ((mode & 002) ? "w" : "-"); + outs() << ((mode & 001) ? "x" : "-"); +} + +// Implement the 't' operation. This function prints out just +// the file names of each of the members. However, if verbose mode is requested +// ('v' modifier) then the file type, permission mode, user, group, size, and +// modification time are also printed. +static void doDisplayTable(StringRef Name, const object::Archive::Child &C) { + if (Verbose) { + Expected ModeOrErr = C.getAccessMode(); + failIfError(ModeOrErr.takeError()); + sys::fs::perms Mode = ModeOrErr.get(); + printMode((Mode >> 6) & 007); + printMode((Mode >> 3) & 007); + printMode(Mode & 007); + Expected UIDOrErr = C.getUID(); + failIfError(UIDOrErr.takeError()); + outs() << ' ' << UIDOrErr.get(); + Expected GIDOrErr = C.getGID(); + failIfError(GIDOrErr.takeError()); + outs() << '/' << GIDOrErr.get(); + Expected Size = C.getSize(); + failIfError(Size.takeError()); + outs() << ' ' << format("%6llu", Size.get()); + auto ModTimeOrErr = C.getLastModified(); + failIfError(ModTimeOrErr.takeError()); + // Note: formatv() only handles the default TimePoint<>, which is in + // nanoseconds. + // TODO: fix format_provider> to allow other units. + sys::TimePoint<> ModTimeInNs = ModTimeOrErr.get(); + outs() << ' ' << formatv("{0:%b %e %H:%M %Y}", ModTimeInNs); + outs() << ' '; + } + + if (C.getParent()->isThin()) { + if (!sys::path::is_absolute(Name)) { + StringRef ParentDir = sys::path::parent_path(ArchiveName); + if (!ParentDir.empty()) + outs() << sys::path::convert_to_slash(ParentDir) << '/'; + } + } + outs() << Name << "\n"; +} + +static StringRef normalizePath(StringRef Path) { + return CompareFullPath ? Path : sys::path::filename(Path); +} + +// Implement the 'x' operation. This function extracts files back to the file +// system. +static void doExtract(StringRef Name, const object::Archive::Child &C) { + // Retain the original mode. + Expected ModeOrErr = C.getAccessMode(); + failIfError(ModeOrErr.takeError()); + sys::fs::perms Mode = ModeOrErr.get(); + + int FD; + failIfError(sys::fs::openFileForWrite(sys::path::filename(Name), FD, + sys::fs::CD_CreateAlways, + sys::fs::F_None, Mode), + Name); + + { + raw_fd_ostream file(FD, false); + + // Get the data and its length + Expected BufOrErr = C.getBuffer(); + failIfError(BufOrErr.takeError()); + StringRef Data = BufOrErr.get(); + + // Write the data. + file.write(Data.data(), Data.size()); + } + + // If we're supposed to retain the original modification times, etc. do so + // now. + if (OriginalDates) { + auto ModTimeOrErr = C.getLastModified(); + failIfError(ModTimeOrErr.takeError()); + failIfError( + sys::fs::setLastAccessAndModificationTime(FD, ModTimeOrErr.get())); + } + + if (close(FD)) + fail("Could not close the file"); +} + +static bool shouldCreateArchive(ArchiveOperation Op) { + switch (Op) { + case Print: + case Delete: + case Move: + case DisplayTable: + case Extract: + case CreateSymTab: + return false; + + case QuickAppend: + case ReplaceOrInsert: + return true; + } + + llvm_unreachable("Missing entry in covered switch."); +} + +static void performReadOperation(ArchiveOperation Operation, + object::Archive *OldArchive) { + if (Operation == Extract && OldArchive->isThin()) + fail("extracting from a thin archive is not supported"); + + bool Filter = !Members.empty(); + { + Error Err = Error::success(); + for (auto &C : OldArchive->children(Err)) { + Expected NameOrErr = C.getName(); + failIfError(NameOrErr.takeError()); + StringRef Name = NameOrErr.get(); + + if (Filter) { + auto I = find_if(Members, [Name](StringRef Path) { + return Name == normalizePath(Path); + }); + if (I == Members.end()) + continue; + Members.erase(I); + } + + switch (Operation) { + default: + llvm_unreachable("Not a read operation"); + case Print: + doPrint(Name, C); + break; + case DisplayTable: + doDisplayTable(Name, C); + break; + case Extract: + doExtract(Name, C); + break; + } + } + failIfError(std::move(Err)); + } + + if (Members.empty()) + return; + for (StringRef Name : Members) + WithColor::error(errs(), ToolName) << "'" << Name << "' was not found\n"; + exit(1); +} + +static void addChildMember(std::vector &Members, + const object::Archive::Child &M, + bool FlattenArchive = false) { + if (Thin && !M.getParent()->isThin()) + fail("Cannot convert a regular archive to a thin one"); + Expected NMOrErr = + NewArchiveMember::getOldMember(M, Deterministic); + failIfError(NMOrErr.takeError()); + // If the child member we're trying to add is thin, use the path relative to + // the archive it's in, so the file resolves correctly. + if (Thin && FlattenArchive) { + StringSaver Saver(Alloc); + Expected NameOrErr = M.getName(); + failIfError(NameOrErr.takeError()); + Expected FileNameOrErr = M.getFullName(); + failIfError(FileNameOrErr.takeError()); + + std::string MemberPath; + if (sys::path::is_absolute(*NameOrErr) && + sys::path::is_absolute(*FileNameOrErr)) { + MemberPath = sys::path::convert_to_slash(*FileNameOrErr); + } else { + MemberPath = computeArchiveRelativePath(ArchiveName, *FileNameOrErr); + } + + NMOrErr->MemberName = Saver.save(MemberPath); + } + if (FlattenArchive && + identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) { + Expected FileNameOrErr = M.getFullName(); + failIfError(FileNameOrErr.takeError()); + object::Archive &Lib = readLibrary(*FileNameOrErr); + // When creating thin archives, only flatten if the member is also thin. + if (!Thin || Lib.isThin()) { + Error Err = Error::success(); + // Only Thin archives are recursively flattened. + for (auto &Child : Lib.children(Err)) + addChildMember(Members, Child, /*FlattenArchive=*/Thin); + failIfError(std::move(Err)); + return; + } + } + Members.push_back(std::move(*NMOrErr)); +} + +static void addMember(std::vector &Members, + StringRef FileName, bool FlattenArchive = false) { + Expected NMOrErr = + NewArchiveMember::getFile(FileName, Deterministic); + failIfError(NMOrErr.takeError(), FileName); + StringSaver Saver(Alloc); + // For regular archives, use the basename of the object path for the member + // name. For thin archives, use the full relative paths so the file resolves + // correctly. + auto getThinMemberPath = [](StringRef FileName) -> std::string { + if (sys::path::is_absolute(FileName)) { + return sys::path::convert_to_slash(FileName); + } + return computeArchiveRelativePath(ArchiveName, FileName); + }; + + NMOrErr->MemberName = Thin ? Saver.save(getThinMemberPath(FileName)) + : sys::path::filename(NMOrErr->MemberName); + if (FlattenArchive && + identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) { + object::Archive &Lib = readLibrary(FileName); + // When creating thin archives, only flatten if the member is also thin. + if (!Thin || Lib.isThin()) { + Error Err = Error::success(); + // Only Thin archives are recursively flattened. + for (auto &Child : Lib.children(Err)) + addChildMember(Members, Child, /*FlattenArchive=*/Thin); + failIfError(std::move(Err)); + return; + } + } + Members.push_back(std::move(*NMOrErr)); +} + +enum InsertAction { + IA_AddOldMember, + IA_AddNewMember, + IA_Delete, + IA_MoveOldMember, + IA_MoveNewMember +}; + +static InsertAction computeInsertAction(ArchiveOperation Operation, + const object::Archive::Child &Member, + StringRef Name, + std::vector::iterator &Pos) { + if (Operation == QuickAppend || Members.empty()) + return IA_AddOldMember; + + auto MI = find_if( + Members, [Name](StringRef Path) { return Name == normalizePath(Path); }); + + if (MI == Members.end()) + return IA_AddOldMember; + + Pos = MI; + + if (Operation == Delete) + return IA_Delete; + + if (Operation == Move) + return IA_MoveOldMember; + + if (Operation == ReplaceOrInsert) { + StringRef PosName = normalizePath(RelPos); + if (!OnlyUpdate) { + if (PosName.empty()) + return IA_AddNewMember; + return IA_MoveNewMember; + } + + // We could try to optimize this to a fstat, but it is not a common + // operation. + sys::fs::file_status Status; + failIfError(sys::fs::status(*MI, Status), *MI); + auto ModTimeOrErr = Member.getLastModified(); + failIfError(ModTimeOrErr.takeError()); + if (Status.getLastModificationTime() < ModTimeOrErr.get()) { + if (PosName.empty()) + return IA_AddOldMember; + return IA_MoveOldMember; + } + + if (PosName.empty()) + return IA_AddNewMember; + return IA_MoveNewMember; + } + llvm_unreachable("No such operation"); +} + +// We have to walk this twice and computing it is not trivial, so creating an +// explicit std::vector is actually fairly efficient. +static std::vector +computeNewArchiveMembers(ArchiveOperation Operation, + object::Archive *OldArchive) { + std::vector Ret; + std::vector Moved; + int InsertPos = -1; + StringRef PosName = normalizePath(RelPos); + if (OldArchive) { + Error Err = Error::success(); + for (auto &Child : OldArchive->children(Err)) { + int Pos = Ret.size(); + Expected NameOrErr = Child.getName(); + failIfError(NameOrErr.takeError()); + StringRef Name = NameOrErr.get(); + if (Name == PosName) { + assert(AddAfter || AddBefore); + if (AddBefore) + InsertPos = Pos; + else + InsertPos = Pos + 1; + } + + std::vector::iterator MemberI = Members.end(); + InsertAction Action = + computeInsertAction(Operation, Child, Name, MemberI); + switch (Action) { + case IA_AddOldMember: + addChildMember(Ret, Child, /*FlattenArchive=*/Thin); + break; + case IA_AddNewMember: + addMember(Ret, *MemberI); + break; + case IA_Delete: + break; + case IA_MoveOldMember: + addChildMember(Moved, Child, /*FlattenArchive=*/Thin); + break; + case IA_MoveNewMember: + addMember(Moved, *MemberI); + break; + } + if (MemberI != Members.end()) + Members.erase(MemberI); + } + failIfError(std::move(Err)); + } + + if (Operation == Delete) + return Ret; + + if (!RelPos.empty() && InsertPos == -1) + fail("Insertion point not found"); + + if (RelPos.empty()) + InsertPos = Ret.size(); + + assert(unsigned(InsertPos) <= Ret.size()); + int Pos = InsertPos; + for (auto &M : Moved) { + Ret.insert(Ret.begin() + Pos, std::move(M)); + ++Pos; + } + + if (AddLibrary) { + assert(Operation == QuickAppend); + for (auto &Member : Members) + addMember(Ret, Member, /*FlattenArchive=*/true); + return Ret; + } + + std::vector NewMembers; + for (auto &Member : Members) + addMember(NewMembers, Member, /*FlattenArchive=*/Thin); + Ret.reserve(Ret.size() + NewMembers.size()); + std::move(NewMembers.begin(), NewMembers.end(), + std::inserter(Ret, std::next(Ret.begin(), InsertPos))); + + return Ret; +} + +static object::Archive::Kind getDefaultForHost() { + return Triple(sys::getProcessTriple()).isOSDarwin() + ? object::Archive::K_DARWIN + : object::Archive::K_GNU; +} + +static object::Archive::Kind getKindFromMember(const NewArchiveMember &Member) { + Expected> OptionalObject = + object::ObjectFile::createObjectFile(Member.Buf->getMemBufferRef()); + + if (OptionalObject) + return isa(**OptionalObject) + ? object::Archive::K_DARWIN + : object::Archive::K_GNU; + + // squelch the error in case we had a non-object file + consumeError(OptionalObject.takeError()); + return getDefaultForHost(); +} + +static void performWriteOperation(ArchiveOperation Operation, + object::Archive *OldArchive, + std::unique_ptr OldArchiveBuf, + std::vector *NewMembersP) { + std::vector NewMembers; + if (!NewMembersP) + NewMembers = computeNewArchiveMembers(Operation, OldArchive); + + object::Archive::Kind Kind; + switch (FormatType) { + case Default: + if (Thin) + Kind = object::Archive::K_GNU; + else if (OldArchive) + Kind = OldArchive->kind(); + else if (NewMembersP) + Kind = !NewMembersP->empty() ? getKindFromMember(NewMembersP->front()) + : getDefaultForHost(); + else + Kind = !NewMembers.empty() ? getKindFromMember(NewMembers.front()) + : getDefaultForHost(); + break; + case GNU: + Kind = object::Archive::K_GNU; + break; + case BSD: + if (Thin) + fail("Only the gnu format has a thin mode"); + Kind = object::Archive::K_BSD; + break; + case DARWIN: + if (Thin) + fail("Only the gnu format has a thin mode"); + Kind = object::Archive::K_DARWIN; + break; + case Unknown: + llvm_unreachable(""); + } + + Error E = + writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab, + Kind, Deterministic, Thin, std::move(OldArchiveBuf)); + failIfError(std::move(E), ArchiveName); +} + +static void createSymbolTable(object::Archive *OldArchive) { + // When an archive is created or modified, if the s option is given, the + // resulting archive will have a current symbol table. If the S option + // is given, it will have no symbol table. + // In summary, we only need to update the symbol table if we have none. + // This is actually very common because of broken build systems that think + // they have to run ranlib. + if (OldArchive->hasSymbolTable()) + return; + + performWriteOperation(CreateSymTab, OldArchive, nullptr, nullptr); +} + +static void performOperation(ArchiveOperation Operation, + object::Archive *OldArchive, + std::unique_ptr OldArchiveBuf, + std::vector *NewMembers) { + switch (Operation) { + case Print: + case DisplayTable: + case Extract: + performReadOperation(Operation, OldArchive); + return; + + case Delete: + case Move: + case QuickAppend: + case ReplaceOrInsert: + performWriteOperation(Operation, OldArchive, std::move(OldArchiveBuf), + NewMembers); + return; + case CreateSymTab: + createSymbolTable(OldArchive); + return; + } + llvm_unreachable("Unknown operation."); +} + +static int performOperation(ArchiveOperation Operation, + std::vector *NewMembers) { + // Create or open the archive object. + ErrorOr> Buf = + MemoryBuffer::getFile(ArchiveName, -1, false); + std::error_code EC = Buf.getError(); + if (EC && EC != errc::no_such_file_or_directory) + fail("error opening '" + ArchiveName + "': " + EC.message() + "!"); + + if (!EC) { + Error Err = Error::success(); + object::Archive Archive(Buf.get()->getMemBufferRef(), Err); + EC = errorToErrorCode(std::move(Err)); + failIfError(EC, + "error loading '" + ArchiveName + "': " + EC.message() + "!"); + if (Archive.isThin()) + CompareFullPath = true; + performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers); + return 0; + } + + assert(EC == errc::no_such_file_or_directory); + + if (!shouldCreateArchive(Operation)) { + failIfError(EC, Twine("error loading '") + ArchiveName + "'"); + } else { + if (!Create) { + // Produce a warning if we should and we're creating the archive + WithColor::warning(errs(), ToolName) + << "creating " << ArchiveName << "\n"; + } + } + + performOperation(Operation, nullptr, nullptr, NewMembers); + return 0; +} + +static void runMRIScript() { + enum class MRICommand { AddLib, AddMod, Create, Delete, Save, End, Invalid }; + + ErrorOr> Buf = MemoryBuffer::getSTDIN(); + failIfError(Buf.getError()); + const MemoryBuffer &Ref = *Buf.get(); + bool Saved = false; + std::vector NewMembers; + + for (line_iterator I(Ref, /*SkipBlanks*/ false), E; I != E; ++I) { + StringRef Line = *I; + Line = Line.split(';').first; + Line = Line.split('*').first; + Line = Line.trim(); + if (Line.empty()) + continue; + StringRef CommandStr, Rest; + std::tie(CommandStr, Rest) = Line.split(' '); + Rest = Rest.trim(); + if (!Rest.empty() && Rest.front() == '"' && Rest.back() == '"') + Rest = Rest.drop_front().drop_back(); + auto Command = StringSwitch(CommandStr.lower()) + .Case("addlib", MRICommand::AddLib) + .Case("addmod", MRICommand::AddMod) + .Case("create", MRICommand::Create) + .Case("delete", MRICommand::Delete) + .Case("save", MRICommand::Save) + .Case("end", MRICommand::End) + .Default(MRICommand::Invalid); + + switch (Command) { + case MRICommand::AddLib: { + object::Archive &Lib = readLibrary(Rest); + { + Error Err = Error::success(); + for (auto &Member : Lib.children(Err)) + addChildMember(NewMembers, Member, /*FlattenArchive=*/Thin); + failIfError(std::move(Err)); + } + break; + } + case MRICommand::AddMod: + addMember(NewMembers, Rest); + break; + case MRICommand::Create: + Create = true; + if (!ArchiveName.empty()) + fail("Editing multiple archives not supported"); + if (Saved) + fail("File already saved"); + ArchiveName = Rest; + break; + case MRICommand::Delete: { + StringRef Name = normalizePath(Rest); + llvm::erase_if(NewMembers, + [=](NewArchiveMember &M) { return M.MemberName == Name; }); + break; + } + case MRICommand::Save: + Saved = true; + break; + case MRICommand::End: + break; + case MRICommand::Invalid: + fail("Unknown command: " + CommandStr); + } + } + + // Nothing to do if not saved. + if (Saved) + performOperation(ReplaceOrInsert, &NewMembers); + exit(0); +} + +static bool handleGenericOption(StringRef arg) { + if (arg == "-help" || arg == "--help") { + printHelpMessage(); + return true; + } + if (arg == "-version" || arg == "--version") { + cl::PrintVersionMessage(); + return true; + } + return false; +} + +static int ar_main(int argc, char **argv) { + SmallVector Argv(argv, argv + argc); + StringSaver Saver(Alloc); + cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv); + for (size_t i = 1; i < Argv.size(); ++i) { + StringRef Arg = Argv[i]; + const char *match; + auto MatchFlagWithArg = [&](const char *expected) { + size_t len = strlen(expected); + if (Arg == expected) { + if (++i >= Argv.size()) + fail(std::string(expected) + " requires an argument"); + match = Argv[i]; + return true; + } + if (Arg.startswith(expected) && Arg.size() > len && Arg[len] == '=') { + match = Arg.data() + len + 1; + return true; + } + return false; + }; + if (handleGenericOption(Argv[i])) + return 0; + if (Arg == "--") { + for (; i < Argv.size(); ++i) + PositionalArgs.push_back(Argv[i]); + break; + } + if (Arg[0] == '-') { + if (Arg.startswith("--")) + Arg = Argv[i] + 2; + else + Arg = Argv[i] + 1; + if (Arg == "M") { + MRI = true; + } else if (MatchFlagWithArg("format")) { + FormatType = StringSwitch(match) + .Case("default", Default) + .Case("gnu", GNU) + .Case("darwin", DARWIN) + .Case("bsd", BSD) + .Default(Unknown); + if (FormatType == Unknown) + fail(std::string("Invalid format ") + match); + } else if (MatchFlagWithArg("plugin")) { + // Ignored. + } else { + Options += Argv[i] + 1; + } + } else if (Options.empty()) { + Options += Argv[i]; + } else { + PositionalArgs.push_back(Argv[i]); + } + } + ArchiveOperation Operation = parseCommandLine(); + return performOperation(Operation, nullptr); +} + +static int ranlib_main(int argc, char **argv) { + bool ArchiveSpecified = false; + for (int i = 1; i < argc; ++i) { + if (handleGenericOption(argv[i])) { + return 0; + } else { + if (ArchiveSpecified) + fail("Exactly one archive should be specified"); + ArchiveSpecified = true; + ArchiveName = argv[i]; + } + } + return performOperation(CreateSymTab, nullptr); +} + +int main(int argc, char **argv) { + InitLLVM X(argc, argv); + ToolName = argv[0]; + + llvm::InitializeAllTargetInfos(); + llvm::InitializeAllTargetMCs(); + llvm::InitializeAllAsmParsers(); + + Stem = sys::path::stem(ToolName); + if (Stem.contains_lower("dlltool")) + return dlltoolDriverMain(makeArrayRef(argv, argc)); + + if (Stem.contains_lower("ranlib")) + return ranlib_main(argc, argv); + + if (Stem.contains_lower("lib")) + return libDriverMain(makeArrayRef(argv, argc)); + + if (Stem.contains_lower("ar")) + return ar_main(argc, argv); + fail("Not ranlib, ar, lib or dlltool!"); +}