1 //===- ArchiveWriter.cpp - ar File Format implementation --------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the writeArchive function.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Object/ArchiveWriter.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/IR/LLVMContext.h"
18 #include "llvm/Object/Archive.h"
19 #include "llvm/Object/ObjectFile.h"
20 #include "llvm/Object/SymbolicFile.h"
21 #include "llvm/Support/EndianStream.h"
22 #include "llvm/Support/Errc.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/Format.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/ToolOutputFile.h"
27 #include "llvm/Support/raw_ostream.h"
28 
29 #if !defined(_MSC_VER) && !defined(__MINGW32__)
30 #include <unistd.h>
31 #else
32 #include <io.h>
33 #endif
34 
35 using namespace llvm;
36 
37 NewArchiveIterator::NewArchiveIterator(const object::Archive::Child &OldMember,
38                                        StringRef Name)
39     : IsNewMember(false), Name(Name), OldMember(OldMember) {}
40 
41 NewArchiveIterator::NewArchiveIterator(StringRef FileName)
42     : IsNewMember(true), Name(FileName), OldMember(nullptr, nullptr, nullptr) {}
43 
44 StringRef NewArchiveIterator::getName() const { return Name; }
45 
46 bool NewArchiveIterator::isNewMember() const { return IsNewMember; }
47 
48 const object::Archive::Child &NewArchiveIterator::getOld() const {
49   assert(!IsNewMember);
50   return OldMember;
51 }
52 
53 StringRef NewArchiveIterator::getNew() const {
54   assert(IsNewMember);
55   return Name;
56 }
57 
58 llvm::ErrorOr<int>
59 NewArchiveIterator::getFD(sys::fs::file_status &NewStatus) const {
60   assert(IsNewMember);
61   int NewFD;
62   if (auto EC = sys::fs::openFileForRead(Name, NewFD))
63     return EC;
64   assert(NewFD != -1);
65 
66   if (auto EC = sys::fs::status(NewFD, NewStatus))
67     return EC;
68 
69   // Opening a directory doesn't make sense. Let it fail.
70   // Linux cannot open directories with open(2), although
71   // cygwin and *bsd can.
72   if (NewStatus.type() == sys::fs::file_type::directory_file)
73     return make_error_code(errc::is_a_directory);
74 
75   return NewFD;
76 }
77 
78 template <typename T>
79 static void printWithSpacePadding(raw_fd_ostream &OS, T Data, unsigned Size,
80                                   bool MayTruncate = false) {
81   uint64_t OldPos = OS.tell();
82   OS << Data;
83   unsigned SizeSoFar = OS.tell() - OldPos;
84   if (Size > SizeSoFar) {
85     OS.indent(Size - SizeSoFar);
86   } else if (Size < SizeSoFar) {
87     assert(MayTruncate && "Data doesn't fit in Size");
88     // Some of the data this is used for (like UID) can be larger than the
89     // space available in the archive format. Truncate in that case.
90     OS.seek(OldPos + Size);
91   }
92 }
93 
94 static void print32(raw_ostream &Out, object::Archive::Kind Kind,
95                     uint32_t Val) {
96   if (Kind == object::Archive::K_GNU)
97     support::endian::Writer<support::big>(Out).write(Val);
98   else
99     support::endian::Writer<support::little>(Out).write(Val);
100 }
101 
102 static void printRestOfMemberHeader(raw_fd_ostream &Out,
103                                     const sys::TimeValue &ModTime, unsigned UID,
104                                     unsigned GID, unsigned Perms,
105                                     unsigned Size) {
106   printWithSpacePadding(Out, ModTime.toEpochTime(), 12);
107   printWithSpacePadding(Out, UID, 6, true);
108   printWithSpacePadding(Out, GID, 6, true);
109   printWithSpacePadding(Out, format("%o", Perms), 8);
110   printWithSpacePadding(Out, Size, 10);
111   Out << "`\n";
112 }
113 
114 static void printGNUSmallMemberHeader(raw_fd_ostream &Out, StringRef Name,
115                                       const sys::TimeValue &ModTime,
116                                       unsigned UID, unsigned GID,
117                                       unsigned Perms, unsigned Size) {
118   printWithSpacePadding(Out, Twine(Name) + "/", 16);
119   printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
120 }
121 
122 static void printBSDMemberHeader(raw_fd_ostream &Out, StringRef Name,
123                                  const sys::TimeValue &ModTime, unsigned UID,
124                                  unsigned GID, unsigned Perms, unsigned Size) {
125   uint64_t PosAfterHeader = Out.tell() + 60 + Name.size();
126   // Pad so that even 64 bit object files are aligned.
127   unsigned Pad = OffsetToAlignment(PosAfterHeader, 8);
128   unsigned NameWithPadding = Name.size() + Pad;
129   printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16);
130   printRestOfMemberHeader(Out, ModTime, UID, GID, Perms,
131                           NameWithPadding + Size);
132   Out << Name;
133   assert(PosAfterHeader == Out.tell());
134   while (Pad--)
135     Out.write(uint8_t(0));
136 }
137 
138 static bool useStringTable(bool Thin, StringRef Name) {
139   return Thin || Name.size() >= 16;
140 }
141 
142 static void
143 printMemberHeader(raw_fd_ostream &Out, object::Archive::Kind Kind, bool Thin,
144                   StringRef Name,
145                   std::vector<unsigned>::iterator &StringMapIndexIter,
146                   const sys::TimeValue &ModTime, unsigned UID, unsigned GID,
147                   unsigned Perms, unsigned Size) {
148   if (Kind == object::Archive::K_BSD)
149     return printBSDMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
150   if (!useStringTable(Thin, Name))
151     return printGNUSmallMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
152   Out << '/';
153   printWithSpacePadding(Out, *StringMapIndexIter++, 15);
154   printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
155 }
156 
157 // Compute the relative path from From to To.
158 static std::string computeRelativePath(StringRef From, StringRef To) {
159   if (sys::path::is_absolute(From) || sys::path::is_absolute(To))
160     return To;
161 
162   StringRef DirFrom = sys::path::parent_path(From);
163   auto FromI = sys::path::begin(DirFrom);
164   auto ToI = sys::path::begin(To);
165   while (*FromI == *ToI) {
166     ++FromI;
167     ++ToI;
168   }
169 
170   SmallString<128> Relative;
171   for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI)
172     sys::path::append(Relative, "..");
173 
174   for (auto ToE = sys::path::end(To); ToI != ToE; ++ToI)
175     sys::path::append(Relative, *ToI);
176 
177   return Relative.str();
178 }
179 
180 static void writeStringTable(raw_fd_ostream &Out, StringRef ArcName,
181                              ArrayRef<NewArchiveIterator> Members,
182                              std::vector<unsigned> &StringMapIndexes,
183                              bool Thin) {
184   unsigned StartOffset = 0;
185   for (const NewArchiveIterator &I : Members) {
186     StringRef Name = sys::path::filename(I.getName());
187     if (!useStringTable(Thin, Name))
188       continue;
189     if (StartOffset == 0) {
190       printWithSpacePadding(Out, "//", 58);
191       Out << "`\n";
192       StartOffset = Out.tell();
193     }
194     StringMapIndexes.push_back(Out.tell() - StartOffset);
195 
196     if (Thin)
197       Out << computeRelativePath(ArcName, I.getName());
198     else
199       Out << Name;
200 
201     Out << "/\n";
202   }
203   if (StartOffset == 0)
204     return;
205   if (Out.tell() % 2)
206     Out << '\n';
207   int Pos = Out.tell();
208   Out.seek(StartOffset - 12);
209   printWithSpacePadding(Out, Pos - StartOffset, 10);
210   Out.seek(Pos);
211 }
212 
213 static sys::TimeValue now(bool Deterministic) {
214   if (!Deterministic)
215     return sys::TimeValue::now();
216   sys::TimeValue TV;
217   TV.fromEpochTime(0);
218   return TV;
219 }
220 
221 // Returns the offset of the first reference to a member offset.
222 static ErrorOr<unsigned>
223 writeSymbolTable(raw_fd_ostream &Out, object::Archive::Kind Kind,
224                  ArrayRef<NewArchiveIterator> Members,
225                  ArrayRef<MemoryBufferRef> Buffers,
226                  std::vector<unsigned> &MemberOffsetRefs, bool Deterministic) {
227   unsigned HeaderStartOffset = 0;
228   unsigned BodyStartOffset = 0;
229   SmallString<128> NameBuf;
230   raw_svector_ostream NameOS(NameBuf);
231   LLVMContext Context;
232   for (unsigned MemberNum = 0, N = Members.size(); MemberNum < N; ++MemberNum) {
233     MemoryBufferRef MemberBuffer = Buffers[MemberNum];
234     Expected<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
235         object::SymbolicFile::createSymbolicFile(
236             MemberBuffer, sys::fs::file_magic::unknown, &Context);
237     if (!ObjOrErr) {
238       // FIXME: check only for "not an object file" errors.
239       consumeError(ObjOrErr.takeError());
240       continue;
241     }
242     object::SymbolicFile &Obj = *ObjOrErr.get();
243 
244     if (!HeaderStartOffset) {
245       HeaderStartOffset = Out.tell();
246       if (Kind == object::Archive::K_GNU)
247         printGNUSmallMemberHeader(Out, "", now(Deterministic), 0, 0, 0, 0);
248       else
249         printBSDMemberHeader(Out, "__.SYMDEF", now(Deterministic), 0, 0, 0, 0);
250       BodyStartOffset = Out.tell();
251       print32(Out, Kind, 0); // number of entries or bytes
252     }
253 
254     for (const object::BasicSymbolRef &S : Obj.symbols()) {
255       uint32_t Symflags = S.getFlags();
256       if (Symflags & object::SymbolRef::SF_FormatSpecific)
257         continue;
258       if (!(Symflags & object::SymbolRef::SF_Global))
259         continue;
260       if (Symflags & object::SymbolRef::SF_Undefined)
261         continue;
262 
263       unsigned NameOffset = NameOS.tell();
264       if (auto EC = S.printName(NameOS))
265         return EC;
266       NameOS << '\0';
267       MemberOffsetRefs.push_back(MemberNum);
268       if (Kind == object::Archive::K_BSD)
269         print32(Out, Kind, NameOffset);
270       print32(Out, Kind, 0); // member offset
271     }
272   }
273 
274   if (HeaderStartOffset == 0)
275     return 0;
276 
277   StringRef StringTable = NameOS.str();
278   if (Kind == object::Archive::K_BSD)
279     print32(Out, Kind, StringTable.size()); // byte count of the string table
280   Out << StringTable;
281 
282   // ld64 requires the next member header to start at an offset that is
283   // 4 bytes aligned.
284   unsigned Pad = OffsetToAlignment(Out.tell(), 4);
285   while (Pad--)
286     Out.write(uint8_t(0));
287 
288   // Patch up the size of the symbol table now that we know how big it is.
289   unsigned Pos = Out.tell();
290   const unsigned MemberHeaderSize = 60;
291   Out.seek(HeaderStartOffset + 48); // offset of the size field.
292   printWithSpacePadding(Out, Pos - MemberHeaderSize - HeaderStartOffset, 10);
293 
294   // Patch up the number of symbols.
295   Out.seek(BodyStartOffset);
296   unsigned NumSyms = MemberOffsetRefs.size();
297   if (Kind == object::Archive::K_GNU)
298     print32(Out, Kind, NumSyms);
299   else
300     print32(Out, Kind, NumSyms * 8);
301 
302   Out.seek(Pos);
303   return BodyStartOffset + 4;
304 }
305 
306 std::pair<StringRef, std::error_code>
307 llvm::writeArchive(StringRef ArcName,
308                    std::vector<NewArchiveIterator> &NewMembers,
309                    bool WriteSymtab, object::Archive::Kind Kind,
310                    bool Deterministic, bool Thin) {
311   SmallString<128> TmpArchive;
312   int TmpArchiveFD;
313   if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
314                                           TmpArchiveFD, TmpArchive))
315     return std::make_pair(ArcName, EC);
316 
317   tool_output_file Output(TmpArchive, TmpArchiveFD);
318   raw_fd_ostream &Out = Output.os();
319   if (Thin)
320     Out << "!<thin>\n";
321   else
322     Out << "!<arch>\n";
323 
324   std::vector<unsigned> MemberOffsetRefs;
325 
326   std::vector<std::unique_ptr<MemoryBuffer>> Buffers;
327   std::vector<MemoryBufferRef> Members;
328   std::vector<sys::fs::file_status> NewMemberStatus;
329 
330   for (unsigned I = 0, N = NewMembers.size(); I < N; ++I) {
331     NewArchiveIterator &Member = NewMembers[I];
332     MemoryBufferRef MemberRef;
333 
334     if (Member.isNewMember()) {
335       StringRef Filename = Member.getNew();
336       NewMemberStatus.resize(NewMemberStatus.size() + 1);
337       sys::fs::file_status &Status = NewMemberStatus.back();
338       ErrorOr<int> FD = Member.getFD(Status);
339       if (auto EC = FD.getError())
340         return std::make_pair(Filename, EC);
341       ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
342           MemoryBuffer::getOpenFile(FD.get(), Filename, Status.getSize(),
343                                     false);
344       if (auto EC = MemberBufferOrErr.getError())
345         return std::make_pair(Filename, EC);
346       if (close(FD.get()) != 0)
347         return std::make_pair(Filename,
348                               std::error_code(errno, std::generic_category()));
349       Buffers.push_back(std::move(MemberBufferOrErr.get()));
350       MemberRef = Buffers.back()->getMemBufferRef();
351     } else {
352       const object::Archive::Child &OldMember = Member.getOld();
353       assert((!Thin || OldMember.getParent()->isThin()) &&
354              "Thin archives cannot refers to member of other archives");
355       ErrorOr<MemoryBufferRef> MemberBufferOrErr =
356           OldMember.getMemoryBufferRef();
357       if (auto EC = MemberBufferOrErr.getError())
358         return std::make_pair("", EC);
359       MemberRef = MemberBufferOrErr.get();
360     }
361     Members.push_back(MemberRef);
362   }
363 
364   unsigned MemberReferenceOffset = 0;
365   if (WriteSymtab) {
366     ErrorOr<unsigned> MemberReferenceOffsetOrErr = writeSymbolTable(
367         Out, Kind, NewMembers, Members, MemberOffsetRefs, Deterministic);
368     if (auto EC = MemberReferenceOffsetOrErr.getError())
369       return std::make_pair(ArcName, EC);
370     MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
371   }
372 
373   std::vector<unsigned> StringMapIndexes;
374   if (Kind != object::Archive::K_BSD)
375     writeStringTable(Out, ArcName, NewMembers, StringMapIndexes, Thin);
376 
377   unsigned MemberNum = 0;
378   unsigned NewMemberNum = 0;
379   std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin();
380   std::vector<unsigned> MemberOffset;
381   for (const NewArchiveIterator &I : NewMembers) {
382     MemoryBufferRef File = Members[MemberNum++];
383 
384     unsigned Pos = Out.tell();
385     MemberOffset.push_back(Pos);
386 
387     sys::TimeValue ModTime;
388     unsigned UID;
389     unsigned GID;
390     unsigned Perms;
391     if (Deterministic) {
392       ModTime.fromEpochTime(0);
393       UID = 0;
394       GID = 0;
395       Perms = 0644;
396     } else if (I.isNewMember()) {
397       const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum];
398       ModTime = Status.getLastModificationTime();
399       UID = Status.getUser();
400       GID = Status.getGroup();
401       Perms = Status.permissions();
402     } else {
403       const object::Archive::Child &OldMember = I.getOld();
404       ModTime = OldMember.getLastModified();
405       UID = OldMember.getUID();
406       GID = OldMember.getGID();
407       Perms = OldMember.getAccessMode();
408     }
409 
410     if (I.isNewMember()) {
411       StringRef FileName = I.getNew();
412       const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum++];
413       printMemberHeader(Out, Kind, Thin, sys::path::filename(FileName),
414                         StringMapIndexIter, ModTime, UID, GID, Perms,
415                         Status.getSize());
416     } else {
417       const object::Archive::Child &OldMember = I.getOld();
418       ErrorOr<uint32_t> Size = OldMember.getSize();
419       if (std::error_code EC = Size.getError())
420         return std::make_pair("", EC);
421       StringRef FileName = I.getName();
422       printMemberHeader(Out, Kind, Thin, sys::path::filename(FileName),
423                         StringMapIndexIter, ModTime, UID, GID, Perms,
424                         Size.get());
425     }
426 
427     if (!Thin)
428       Out << File.getBuffer();
429 
430     if (Out.tell() % 2)
431       Out << '\n';
432   }
433 
434   if (MemberReferenceOffset) {
435     Out.seek(MemberReferenceOffset);
436     for (unsigned MemberNum : MemberOffsetRefs) {
437       if (Kind == object::Archive::K_BSD)
438         Out.seek(Out.tell() + 4); // skip over the string offset
439       print32(Out, Kind, MemberOffset[MemberNum]);
440     }
441   }
442 
443   Output.keep();
444   Out.close();
445   sys::fs::rename(TmpArchive, ArcName);
446   return std::make_pair("", std::error_code());
447 }
448