1 //===- ArchiveWriter.cpp - ar File Format implementation --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the writeArchive function.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Object/ArchiveWriter.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/BinaryFormat/Magic.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/Object/Archive.h"
20 #include "llvm/Object/ObjectFile.h"
21 #include "llvm/Object/SymbolicFile.h"
22 #include "llvm/Support/EndianStream.h"
23 #include "llvm/Support/Errc.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/Format.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/ToolOutputFile.h"
28 #include "llvm/Support/raw_ostream.h"
30 #if !defined(_MSC_VER) && !defined(__MINGW32__)
38 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef)
39 : Buf(MemoryBuffer::getMemBuffer(BufRef, false)),
40 MemberName(BufRef.getBufferIdentifier()) {}
42 Expected<NewArchiveMember>
43 NewArchiveMember::getOldMember(const object::Archive::Child &OldMember,
45 Expected<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef();
47 return BufOrErr.takeError();
50 assert(M.IsNew == false);
51 M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false);
52 M.MemberName = M.Buf->getBufferIdentifier();
54 auto ModTimeOrErr = OldMember.getLastModified();
56 return ModTimeOrErr.takeError();
57 M.ModTime = ModTimeOrErr.get();
58 Expected<unsigned> UIDOrErr = OldMember.getUID();
60 return UIDOrErr.takeError();
61 M.UID = UIDOrErr.get();
62 Expected<unsigned> GIDOrErr = OldMember.getGID();
64 return GIDOrErr.takeError();
65 M.GID = GIDOrErr.get();
66 Expected<sys::fs::perms> AccessModeOrErr = OldMember.getAccessMode();
68 return AccessModeOrErr.takeError();
69 M.Perms = AccessModeOrErr.get();
74 Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName,
76 sys::fs::file_status Status;
78 if (auto EC = sys::fs::openFileForRead(FileName, FD))
79 return errorCodeToError(EC);
82 if (auto EC = sys::fs::status(FD, Status))
83 return errorCodeToError(EC);
85 // Opening a directory doesn't make sense. Let it fail.
86 // Linux cannot open directories with open(2), although
87 // cygwin and *bsd can.
88 if (Status.type() == sys::fs::file_type::directory_file)
89 return errorCodeToError(make_error_code(errc::is_a_directory));
91 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
92 MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false);
93 if (!MemberBufferOrErr)
94 return errorCodeToError(MemberBufferOrErr.getError());
97 return errorCodeToError(std::error_code(errno, std::generic_category()));
101 M.Buf = std::move(*MemberBufferOrErr);
102 M.MemberName = M.Buf->getBufferIdentifier();
103 if (!Deterministic) {
104 M.ModTime = std::chrono::time_point_cast<std::chrono::seconds>(
105 Status.getLastModificationTime());
106 M.UID = Status.getUser();
107 M.GID = Status.getGroup();
108 M.Perms = Status.permissions();
113 template <typename T>
114 static void printWithSpacePadding(raw_fd_ostream &OS, T Data, unsigned Size,
115 bool MayTruncate = false) {
116 uint64_t OldPos = OS.tell();
118 unsigned SizeSoFar = OS.tell() - OldPos;
119 if (Size > SizeSoFar) {
120 OS.indent(Size - SizeSoFar);
121 } else if (Size < SizeSoFar) {
122 assert(MayTruncate && "Data doesn't fit in Size");
123 // Some of the data this is used for (like UID) can be larger than the
124 // space available in the archive format. Truncate in that case.
125 OS.seek(OldPos + Size);
129 static bool isBSDLike(object::Archive::Kind Kind) {
131 case object::Archive::K_GNU:
133 case object::Archive::K_BSD:
134 case object::Archive::K_DARWIN:
136 case object::Archive::K_MIPS64:
137 case object::Archive::K_DARWIN64:
138 case object::Archive::K_COFF:
141 llvm_unreachable("not supported for writting");
144 static void print32(raw_ostream &Out, object::Archive::Kind Kind,
147 support::endian::Writer<support::little>(Out).write(Val);
149 support::endian::Writer<support::big>(Out).write(Val);
152 static void printRestOfMemberHeader(
153 raw_fd_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime,
154 unsigned UID, unsigned GID, unsigned Perms, unsigned Size) {
155 printWithSpacePadding(Out, sys::toTimeT(ModTime), 12);
156 printWithSpacePadding(Out, UID, 6, true);
157 printWithSpacePadding(Out, GID, 6, true);
158 printWithSpacePadding(Out, format("%o", Perms), 8);
159 printWithSpacePadding(Out, Size, 10);
164 printGNUSmallMemberHeader(raw_fd_ostream &Out, StringRef Name,
165 const sys::TimePoint<std::chrono::seconds> &ModTime,
166 unsigned UID, unsigned GID, unsigned Perms,
168 printWithSpacePadding(Out, Twine(Name) + "/", 16);
169 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
173 printBSDMemberHeader(raw_fd_ostream &Out, StringRef Name,
174 const sys::TimePoint<std::chrono::seconds> &ModTime,
175 unsigned UID, unsigned GID, unsigned Perms,
177 uint64_t PosAfterHeader = Out.tell() + 60 + Name.size();
178 // Pad so that even 64 bit object files are aligned.
179 unsigned Pad = OffsetToAlignment(PosAfterHeader, 8);
180 unsigned NameWithPadding = Name.size() + Pad;
181 printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16);
182 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms,
183 NameWithPadding + Size);
185 assert(PosAfterHeader == Out.tell());
187 Out.write(uint8_t(0));
190 static bool useStringTable(bool Thin, StringRef Name) {
191 return Thin || Name.size() >= 16 || Name.contains('/');
195 printMemberHeader(raw_fd_ostream &Out, object::Archive::Kind Kind, bool Thin,
197 std::vector<unsigned>::iterator &StringMapIndexIter,
198 const sys::TimePoint<std::chrono::seconds> &ModTime,
199 unsigned UID, unsigned GID, unsigned Perms, unsigned Size) {
201 return printBSDMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
202 if (!useStringTable(Thin, Name))
203 return printGNUSmallMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
205 printWithSpacePadding(Out, *StringMapIndexIter++, 15);
206 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
209 // Compute the relative path from From to To.
210 static std::string computeRelativePath(StringRef From, StringRef To) {
211 if (sys::path::is_absolute(From) || sys::path::is_absolute(To))
214 StringRef DirFrom = sys::path::parent_path(From);
215 auto FromI = sys::path::begin(DirFrom);
216 auto ToI = sys::path::begin(To);
217 while (*FromI == *ToI) {
222 SmallString<128> Relative;
223 for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI)
224 sys::path::append(Relative, "..");
226 for (auto ToE = sys::path::end(To); ToI != ToE; ++ToI)
227 sys::path::append(Relative, *ToI);
230 // Replace backslashes with slashes so that the path is portable between *nix
232 std::replace(Relative.begin(), Relative.end(), '\\', '/');
235 return Relative.str();
238 static void writeStringTable(raw_fd_ostream &Out, StringRef ArcName,
239 ArrayRef<NewArchiveMember> Members,
240 std::vector<unsigned> &StringMapIndexes,
242 unsigned StartOffset = 0;
243 for (const NewArchiveMember &M : Members) {
244 StringRef Path = M.Buf->getBufferIdentifier();
245 StringRef Name = M.MemberName;
246 if (!useStringTable(Thin, Name))
248 if (StartOffset == 0) {
249 printWithSpacePadding(Out, "//", 58);
251 StartOffset = Out.tell();
253 StringMapIndexes.push_back(Out.tell() - StartOffset);
257 Out << computeRelativePath(ArcName, Path);
259 Out << M.Buf->getBufferIdentifier();
265 if (StartOffset == 0)
269 int Pos = Out.tell();
270 Out.seek(StartOffset - 12);
271 printWithSpacePadding(Out, Pos - StartOffset, 10);
275 static sys::TimePoint<std::chrono::seconds> now(bool Deterministic) {
276 using namespace std::chrono;
279 return time_point_cast<seconds>(system_clock::now());
280 return sys::TimePoint<seconds>();
283 // Returns the offset of the first reference to a member offset.
284 static ErrorOr<unsigned>
285 writeSymbolTable(raw_fd_ostream &Out, object::Archive::Kind Kind,
286 ArrayRef<NewArchiveMember> Members,
287 std::vector<unsigned> &MemberOffsetRefs, bool Deterministic) {
288 unsigned HeaderStartOffset = 0;
289 unsigned BodyStartOffset = 0;
290 SmallString<128> NameBuf;
291 raw_svector_ostream NameOS(NameBuf);
293 for (unsigned MemberNum = 0, N = Members.size(); MemberNum < N; ++MemberNum) {
294 MemoryBufferRef MemberBuffer = Members[MemberNum].Buf->getMemBufferRef();
295 Expected<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
296 object::SymbolicFile::createSymbolicFile(
297 MemberBuffer, llvm::file_magic::unknown, &Context);
299 // FIXME: check only for "not an object file" errors.
300 consumeError(ObjOrErr.takeError());
303 object::SymbolicFile &Obj = *ObjOrErr.get();
305 if (!HeaderStartOffset) {
306 HeaderStartOffset = Out.tell();
308 printBSDMemberHeader(Out, "__.SYMDEF", now(Deterministic), 0, 0, 0, 0);
310 printGNUSmallMemberHeader(Out, "", now(Deterministic), 0, 0, 0, 0);
311 BodyStartOffset = Out.tell();
312 print32(Out, Kind, 0); // number of entries or bytes
315 for (const object::BasicSymbolRef &S : Obj.symbols()) {
316 uint32_t Symflags = S.getFlags();
317 if (Symflags & object::SymbolRef::SF_FormatSpecific)
319 if (!(Symflags & object::SymbolRef::SF_Global))
321 if (Symflags & object::SymbolRef::SF_Undefined)
324 unsigned NameOffset = NameOS.tell();
325 if (auto EC = S.printName(NameOS))
328 MemberOffsetRefs.push_back(MemberNum);
330 print32(Out, Kind, NameOffset);
331 print32(Out, Kind, 0); // member offset
335 if (HeaderStartOffset == 0)
338 // ld64 prefers the cctools type archive which pads its string table to a
339 // boundary of sizeof(int32_t).
341 for (unsigned P = OffsetToAlignment(NameOS.tell(), sizeof(int32_t)); P--;)
344 StringRef StringTable = NameOS.str();
346 print32(Out, Kind, StringTable.size()); // byte count of the string table
348 // If there are no symbols, emit an empty symbol table, to satisfy Solaris
349 // tools, older versions of which expect a symbol table in a non-empty
350 // archive, regardless of whether there are any symbols in it.
351 if (StringTable.size() == 0)
352 print32(Out, Kind, 0);
354 // ld64 requires the next member header to start at an offset that is
356 unsigned Pad = OffsetToAlignment(Out.tell(), 4);
358 Out.write(uint8_t(0));
360 // Patch up the size of the symbol table now that we know how big it is.
361 unsigned Pos = Out.tell();
362 const unsigned MemberHeaderSize = 60;
363 Out.seek(HeaderStartOffset + 48); // offset of the size field.
364 printWithSpacePadding(Out, Pos - MemberHeaderSize - HeaderStartOffset, 10);
366 // Patch up the number of symbols.
367 Out.seek(BodyStartOffset);
368 unsigned NumSyms = MemberOffsetRefs.size();
370 print32(Out, Kind, NumSyms * 8);
372 print32(Out, Kind, NumSyms);
375 return BodyStartOffset + 4;
378 std::pair<StringRef, std::error_code>
379 llvm::writeArchive(StringRef ArcName,
380 std::vector<NewArchiveMember> &NewMembers,
381 bool WriteSymtab, object::Archive::Kind Kind,
382 bool Deterministic, bool Thin,
383 std::unique_ptr<MemoryBuffer> OldArchiveBuf) {
384 assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode");
385 SmallString<128> TmpArchive;
387 if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
388 TmpArchiveFD, TmpArchive))
389 return std::make_pair(ArcName, EC);
391 tool_output_file Output(TmpArchive, TmpArchiveFD);
392 raw_fd_ostream &Out = Output.os();
398 std::vector<unsigned> MemberOffsetRefs;
400 unsigned MemberReferenceOffset = 0;
402 ErrorOr<unsigned> MemberReferenceOffsetOrErr = writeSymbolTable(
403 Out, Kind, NewMembers, MemberOffsetRefs, Deterministic);
404 if (auto EC = MemberReferenceOffsetOrErr.getError())
405 return std::make_pair(ArcName, EC);
406 MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
409 std::vector<unsigned> StringMapIndexes;
410 if (!isBSDLike(Kind))
411 writeStringTable(Out, ArcName, NewMembers, StringMapIndexes, Thin);
413 std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin();
414 std::vector<unsigned> MemberOffset;
415 for (const NewArchiveMember &M : NewMembers) {
416 MemoryBufferRef File = M.Buf->getMemBufferRef();
417 unsigned Padding = 0;
419 unsigned Pos = Out.tell();
420 MemberOffset.push_back(Pos);
422 // ld64 expects the members to be 8-byte aligned for 64-bit content and at
423 // least 4-byte aligned for 32-bit content. Opt for the larger encoding
424 // uniformly. This matches the behaviour with cctools and ensures that ld64
425 // is happy with archives that we generate.
426 if (Kind == object::Archive::K_DARWIN)
427 Padding = OffsetToAlignment(M.Buf->getBufferSize(), 8);
429 printMemberHeader(Out, Kind, Thin, M.MemberName, StringMapIndexIter,
430 M.ModTime, M.UID, M.GID, M.Perms,
431 M.Buf->getBufferSize() + Padding);
434 Out << File.getBuffer();
442 if (MemberReferenceOffset) {
443 Out.seek(MemberReferenceOffset);
444 for (unsigned MemberNum : MemberOffsetRefs) {
446 Out.seek(Out.tell() + 4); // skip over the string offset
447 print32(Out, Kind, MemberOffset[MemberNum]);
454 // At this point, we no longer need whatever backing memory
455 // was used to generate the NewMembers. On Windows, this buffer
456 // could be a mapped view of the file we want to replace (if
457 // we're updating an existing archive, say). In that case, the
458 // rename would still succeed, but it would leave behind a
459 // temporary file (actually the original file renamed) because
460 // a file cannot be deleted while there's a handle open on it,
461 // only renamed. So by freeing this buffer, this ensures that
462 // the last open handle on the destination file, if any, is
463 // closed before we attempt to rename.
464 OldArchiveBuf.reset();
466 sys::fs::rename(TmpArchive, ArcName);
467 return std::make_pair("", std::error_code());