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(object::Archive::child_iterator I,
38                                        StringRef Name)
39     : IsNewMember(false), Name(Name), OldI(I) {}
40 
41 NewArchiveIterator::NewArchiveIterator(StringRef NewFilename, StringRef Name)
42     : IsNewMember(true), Name(Name), NewFilename(NewFilename) {}
43 
44 StringRef NewArchiveIterator::getName() const { return Name; }
45 
46 bool NewArchiveIterator::isNewMember() const { return IsNewMember; }
47 
48 object::Archive::child_iterator NewArchiveIterator::getOld() const {
49   assert(!IsNewMember);
50   return OldI;
51 }
52 
53 StringRef NewArchiveIterator::getNew() const {
54   assert(IsNewMember);
55   return NewFilename;
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(NewFilename, 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 void
139 printMemberHeader(raw_fd_ostream &Out, object::Archive::Kind Kind,
140                   StringRef Name,
141                   std::vector<unsigned>::iterator &StringMapIndexIter,
142                   const sys::TimeValue &ModTime, unsigned UID, unsigned GID,
143                   unsigned Perms, unsigned Size) {
144   if (Kind == object::Archive::K_BSD)
145     return printBSDMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
146   if (Name.size() < 16)
147     return printGNUSmallMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
148   Out << '/';
149   printWithSpacePadding(Out, *StringMapIndexIter++, 15);
150   printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
151 }
152 
153 static void writeStringTable(raw_fd_ostream &Out,
154                              ArrayRef<NewArchiveIterator> Members,
155                              std::vector<unsigned> &StringMapIndexes) {
156   unsigned StartOffset = 0;
157   for (const NewArchiveIterator &I : Members) {
158     StringRef Name = I.getName();
159     if (Name.size() < 16)
160       continue;
161     if (StartOffset == 0) {
162       printWithSpacePadding(Out, "//", 58);
163       Out << "`\n";
164       StartOffset = Out.tell();
165     }
166     StringMapIndexes.push_back(Out.tell() - StartOffset);
167     Out << Name << "/\n";
168   }
169   if (StartOffset == 0)
170     return;
171   if (Out.tell() % 2)
172     Out << '\n';
173   int Pos = Out.tell();
174   Out.seek(StartOffset - 12);
175   printWithSpacePadding(Out, Pos - StartOffset, 10);
176   Out.seek(Pos);
177 }
178 
179 static sys::TimeValue now(bool Deterministic) {
180   if (!Deterministic)
181     return sys::TimeValue::now();
182   sys::TimeValue TV;
183   TV.fromEpochTime(0);
184   return TV;
185 }
186 
187 // Returns the offset of the first reference to a member offset.
188 static ErrorOr<unsigned>
189 writeSymbolTable(raw_fd_ostream &Out, object::Archive::Kind Kind,
190                  ArrayRef<NewArchiveIterator> Members,
191                  ArrayRef<MemoryBufferRef> Buffers,
192                  std::vector<unsigned> &MemberOffsetRefs, bool Deterministic) {
193   unsigned HeaderStartOffset = 0;
194   unsigned BodyStartOffset = 0;
195   SmallString<128> NameBuf;
196   raw_svector_ostream NameOS(NameBuf);
197   LLVMContext Context;
198   for (unsigned MemberNum = 0, N = Members.size(); MemberNum < N; ++MemberNum) {
199     MemoryBufferRef MemberBuffer = Buffers[MemberNum];
200     ErrorOr<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
201         object::SymbolicFile::createSymbolicFile(
202             MemberBuffer, sys::fs::file_magic::unknown, &Context);
203     if (!ObjOrErr)
204       continue;  // FIXME: check only for "not an object file" errors.
205     object::SymbolicFile &Obj = *ObjOrErr.get();
206 
207     if (!HeaderStartOffset) {
208       HeaderStartOffset = Out.tell();
209       if (Kind == object::Archive::K_GNU)
210         printGNUSmallMemberHeader(Out, "", now(Deterministic), 0, 0, 0, 0);
211       else
212         printBSDMemberHeader(Out, "__.SYMDEF", now(Deterministic), 0, 0, 0, 0);
213       BodyStartOffset = Out.tell();
214       print32(Out, Kind, 0); // number of entries or bytes
215     }
216 
217     for (const object::BasicSymbolRef &S : Obj.symbols()) {
218       uint32_t Symflags = S.getFlags();
219       if (Symflags & object::SymbolRef::SF_FormatSpecific)
220         continue;
221       if (!(Symflags & object::SymbolRef::SF_Global))
222         continue;
223       if (Symflags & object::SymbolRef::SF_Undefined)
224         continue;
225 
226       unsigned NameOffset = NameOS.tell();
227       if (auto EC = S.printName(NameOS))
228         return EC;
229       NameOS << '\0';
230       MemberOffsetRefs.push_back(MemberNum);
231       if (Kind == object::Archive::K_BSD)
232         print32(Out, Kind, NameOffset);
233       print32(Out, Kind, 0); // member offset
234     }
235   }
236 
237   if (HeaderStartOffset == 0)
238     return 0;
239 
240   StringRef StringTable = NameOS.str();
241   if (Kind == object::Archive::K_BSD)
242     print32(Out, Kind, StringTable.size()); // byte count of the string table
243   Out << StringTable;
244 
245   // ld64 requires the next member header to start at an offset that is
246   // 4 bytes aligned.
247   unsigned Pad = OffsetToAlignment(Out.tell(), 4);
248   while (Pad--)
249     Out.write(uint8_t(0));
250 
251   // Patch up the size of the symbol table now that we know how big it is.
252   unsigned Pos = Out.tell();
253   const unsigned MemberHeaderSize = 60;
254   Out.seek(HeaderStartOffset + 48); // offset of the size field.
255   printWithSpacePadding(Out, Pos - MemberHeaderSize - HeaderStartOffset, 10);
256 
257   // Patch up the number of symbols.
258   Out.seek(BodyStartOffset);
259   unsigned NumSyms = MemberOffsetRefs.size();
260   if (Kind == object::Archive::K_GNU)
261     print32(Out, Kind, NumSyms);
262   else
263     print32(Out, Kind, NumSyms * 8);
264 
265   Out.seek(Pos);
266   return BodyStartOffset + 4;
267 }
268 
269 std::pair<StringRef, std::error_code> llvm::writeArchive(
270     StringRef ArcName, std::vector<NewArchiveIterator> &NewMembers,
271     bool WriteSymtab, object::Archive::Kind Kind, bool Deterministic) {
272   SmallString<128> TmpArchive;
273   int TmpArchiveFD;
274   if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
275                                           TmpArchiveFD, TmpArchive))
276     return std::make_pair(ArcName, EC);
277 
278   tool_output_file Output(TmpArchive, TmpArchiveFD);
279   raw_fd_ostream &Out = Output.os();
280   Out << "!<arch>\n";
281 
282   std::vector<unsigned> MemberOffsetRefs;
283 
284   std::vector<std::unique_ptr<MemoryBuffer>> Buffers;
285   std::vector<MemoryBufferRef> Members;
286   std::vector<sys::fs::file_status> NewMemberStatus;
287 
288   for (unsigned I = 0, N = NewMembers.size(); I < N; ++I) {
289     NewArchiveIterator &Member = NewMembers[I];
290     MemoryBufferRef MemberRef;
291 
292     if (Member.isNewMember()) {
293       StringRef Filename = Member.getNew();
294       NewMemberStatus.resize(NewMemberStatus.size() + 1);
295       sys::fs::file_status &Status = NewMemberStatus.back();
296       ErrorOr<int> FD = Member.getFD(Status);
297       if (auto EC = FD.getError())
298         return std::make_pair(Filename, EC);
299       ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
300           MemoryBuffer::getOpenFile(FD.get(), Filename, Status.getSize(),
301                                     false);
302       if (auto EC = MemberBufferOrErr.getError())
303         return std::make_pair(Filename, EC);
304       if (close(FD.get()) != 0)
305         return std::make_pair(Filename,
306                               std::error_code(errno, std::generic_category()));
307       Buffers.push_back(std::move(MemberBufferOrErr.get()));
308       MemberRef = Buffers.back()->getMemBufferRef();
309     } else {
310       object::Archive::child_iterator OldMember = Member.getOld();
311       ErrorOr<MemoryBufferRef> MemberBufferOrErr =
312           OldMember->getMemoryBufferRef();
313       if (auto EC = MemberBufferOrErr.getError())
314         return std::make_pair("", EC);
315       MemberRef = MemberBufferOrErr.get();
316     }
317     Members.push_back(MemberRef);
318   }
319 
320   unsigned MemberReferenceOffset = 0;
321   if (WriteSymtab) {
322     ErrorOr<unsigned> MemberReferenceOffsetOrErr = writeSymbolTable(
323         Out, Kind, NewMembers, Members, MemberOffsetRefs, Deterministic);
324     if (auto EC = MemberReferenceOffsetOrErr.getError())
325       return std::make_pair(ArcName, EC);
326     MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
327   }
328 
329   std::vector<unsigned> StringMapIndexes;
330   if (Kind != object::Archive::K_BSD)
331     writeStringTable(Out, NewMembers, StringMapIndexes);
332 
333   unsigned MemberNum = 0;
334   unsigned NewMemberNum = 0;
335   std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin();
336   std::vector<unsigned> MemberOffset;
337   for (const NewArchiveIterator &I : NewMembers) {
338     MemoryBufferRef File = Members[MemberNum++];
339 
340     unsigned Pos = Out.tell();
341     MemberOffset.push_back(Pos);
342 
343     sys::TimeValue ModTime;
344     unsigned UID;
345     unsigned GID;
346     unsigned Perms;
347     if (Deterministic) {
348       ModTime.fromEpochTime(0);
349       UID = 0;
350       GID = 0;
351       Perms = 0644;
352     } else if (I.isNewMember()) {
353       const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum];
354       ModTime = Status.getLastModificationTime();
355       UID = Status.getUser();
356       GID = Status.getGroup();
357       Perms = Status.permissions();
358     } else {
359       object::Archive::child_iterator OldMember = I.getOld();
360       ModTime = OldMember->getLastModified();
361       UID = OldMember->getUID();
362       GID = OldMember->getGID();
363       Perms = OldMember->getAccessMode();
364     }
365 
366     if (I.isNewMember()) {
367       StringRef FileName = I.getNew();
368       const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum++];
369       printMemberHeader(Out, Kind, sys::path::filename(FileName),
370                         StringMapIndexIter, ModTime, UID, GID, Perms,
371                         Status.getSize());
372     } else {
373       object::Archive::child_iterator OldMember = I.getOld();
374       printMemberHeader(Out, Kind, I.getName(), StringMapIndexIter, ModTime,
375                         UID, GID, Perms, OldMember->getSize());
376     }
377 
378     Out << File.getBuffer();
379 
380     if (Out.tell() % 2)
381       Out << '\n';
382   }
383 
384   if (MemberReferenceOffset) {
385     Out.seek(MemberReferenceOffset);
386     for (unsigned MemberNum : MemberOffsetRefs) {
387       if (Kind == object::Archive::K_BSD)
388         Out.seek(Out.tell() + 4); // skip over the string offset
389       print32(Out, Kind, MemberOffset[MemberNum]);
390     }
391   }
392 
393   Output.keep();
394   Out.close();
395   sys::fs::rename(TmpArchive, ArcName);
396   return std::make_pair("", std::error_code());
397 }
398