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/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/ErrorHandling.h"
22 #include "llvm/Support/Format.h"
23 #include "llvm/Support/Path.h"
24 #include "llvm/Support/ToolOutputFile.h"
25 #include "llvm/Support/raw_ostream.h"
27 #if !defined(_MSC_VER) && !defined(__MINGW32__)
35 NewArchiveIterator::NewArchiveIterator() {}
37 NewArchiveIterator::NewArchiveIterator(object::Archive::child_iterator I,
39 : IsNewMember(false), Name(Name), OldI(I) {}
41 NewArchiveIterator::NewArchiveIterator(StringRef NewFilename, StringRef Name)
42 : IsNewMember(true), Name(Name), NewFilename(NewFilename) {}
44 StringRef NewArchiveIterator::getName() const { return Name; }
46 bool NewArchiveIterator::isNewMember() const { return IsNewMember; }
48 object::Archive::child_iterator NewArchiveIterator::getOld() const {
53 StringRef NewArchiveIterator::getNew() const {
59 NewArchiveIterator::getFD(sys::fs::file_status &NewStatus) const {
62 if (auto EC = sys::fs::openFileForRead(NewFilename, NewFD))
66 if (auto EC = sys::fs::status(NewFD, NewStatus))
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(std::errc::is_a_directory);
79 static void printWithSpacePadding(raw_fd_ostream &OS, T Data, unsigned Size,
80 bool MayTruncate = false) {
81 uint64_t OldPos = OS.tell();
83 unsigned SizeSoFar = OS.tell() - OldPos;
84 if (Size > SizeSoFar) {
85 unsigned Remaining = Size - SizeSoFar;
86 for (unsigned I = 0; I < Remaining; ++I)
88 } else if (Size < SizeSoFar) {
89 assert(MayTruncate && "Data doesn't fit in Size");
90 // Some of the data this is used for (like UID) can be larger than the
91 // space available in the archive format. Truncate in that case.
92 OS.seek(OldPos + Size);
96 static void print32BE(raw_fd_ostream &Out, unsigned Val) {
97 // FIXME: Should use Endian.h here.
98 for (int I = 3; I >= 0; --I) {
99 char V = (Val >> (8 * I)) & 0xff;
104 static void printRestOfMemberHeader(raw_fd_ostream &Out,
105 const sys::TimeValue &ModTime, unsigned UID,
106 unsigned GID, unsigned Perms,
108 printWithSpacePadding(Out, ModTime.toEpochTime(), 12);
109 printWithSpacePadding(Out, UID, 6, true);
110 printWithSpacePadding(Out, GID, 6, true);
111 printWithSpacePadding(Out, format("%o", Perms), 8);
112 printWithSpacePadding(Out, Size, 10);
116 static void printMemberHeader(raw_fd_ostream &Out, StringRef Name,
117 const sys::TimeValue &ModTime, unsigned UID,
118 unsigned GID, unsigned Perms, unsigned Size) {
119 printWithSpacePadding(Out, Twine(Name) + "/", 16);
120 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
123 static void printMemberHeader(raw_fd_ostream &Out, unsigned NameOffset,
124 const sys::TimeValue &ModTime, unsigned UID,
125 unsigned GID, unsigned Perms, unsigned Size) {
127 printWithSpacePadding(Out, NameOffset, 15);
128 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
131 static void writeStringTable(raw_fd_ostream &Out,
132 ArrayRef<NewArchiveIterator> Members,
133 std::vector<unsigned> &StringMapIndexes) {
134 unsigned StartOffset = 0;
135 for (ArrayRef<NewArchiveIterator>::iterator I = Members.begin(),
138 StringRef Name = I->getName();
139 if (Name.size() < 16)
141 if (StartOffset == 0) {
142 printWithSpacePadding(Out, "//", 58);
144 StartOffset = Out.tell();
146 StringMapIndexes.push_back(Out.tell() - StartOffset);
147 Out << Name << "/\n";
149 if (StartOffset == 0)
153 int Pos = Out.tell();
154 Out.seek(StartOffset - 12);
155 printWithSpacePadding(Out, Pos - StartOffset, 10);
159 // Returns the offset of the first reference to a member offset.
160 static ErrorOr<unsigned>
161 writeSymbolTable(raw_fd_ostream &Out, ArrayRef<NewArchiveIterator> Members,
162 ArrayRef<MemoryBufferRef> Buffers,
163 std::vector<unsigned> &MemberOffsetRefs) {
164 unsigned StartOffset = 0;
165 unsigned MemberNum = 0;
167 raw_string_ostream NameOS(NameBuf);
168 unsigned NumSyms = 0;
170 for (ArrayRef<NewArchiveIterator>::iterator I = Members.begin(),
172 I != E; ++I, ++MemberNum) {
173 MemoryBufferRef MemberBuffer = Buffers[MemberNum];
174 ErrorOr<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
175 object::SymbolicFile::createSymbolicFile(
176 MemberBuffer, sys::fs::file_magic::unknown, &Context);
178 continue; // FIXME: check only for "not an object file" errors.
179 object::SymbolicFile &Obj = *ObjOrErr.get();
182 printMemberHeader(Out, "", sys::TimeValue::now(), 0, 0, 0, 0);
183 StartOffset = Out.tell();
187 for (const object::BasicSymbolRef &S : Obj.symbols()) {
188 uint32_t Symflags = S.getFlags();
189 if (Symflags & object::SymbolRef::SF_FormatSpecific)
191 if (!(Symflags & object::SymbolRef::SF_Global))
193 if (Symflags & object::SymbolRef::SF_Undefined)
195 if (auto EC = S.printName(NameOS))
199 MemberOffsetRefs.push_back(MemberNum);
205 if (StartOffset == 0)
211 unsigned Pos = Out.tell();
212 Out.seek(StartOffset - 12);
213 printWithSpacePadding(Out, Pos - StartOffset, 10);
214 Out.seek(StartOffset);
215 print32BE(Out, NumSyms);
217 return StartOffset + 4;
220 std::pair<StringRef, std::error_code>
221 llvm::writeArchive(StringRef ArcName,
222 std::vector<NewArchiveIterator> &NewMembers,
224 SmallString<128> TmpArchive;
226 if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
227 TmpArchiveFD, TmpArchive))
228 return std::make_pair(ArcName, EC);
230 tool_output_file Output(TmpArchive, TmpArchiveFD);
231 raw_fd_ostream &Out = Output.os();
234 std::vector<unsigned> MemberOffsetRefs;
236 std::vector<std::unique_ptr<MemoryBuffer>> Buffers;
237 std::vector<MemoryBufferRef> Members;
238 std::vector<sys::fs::file_status> NewMemberStatus;
240 for (unsigned I = 0, N = NewMembers.size(); I < N; ++I) {
241 NewArchiveIterator &Member = NewMembers[I];
242 MemoryBufferRef MemberRef;
244 if (Member.isNewMember()) {
245 StringRef Filename = Member.getNew();
246 NewMemberStatus.resize(NewMemberStatus.size() + 1);
247 sys::fs::file_status &Status = NewMemberStatus.back();
248 ErrorOr<int> FD = Member.getFD(Status);
249 if (auto EC = FD.getError())
250 return std::make_pair(Filename, EC);
251 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
252 MemoryBuffer::getOpenFile(FD.get(), Filename, Status.getSize(),
254 if (auto EC = MemberBufferOrErr.getError())
255 return std::make_pair(Filename, EC);
256 if (close(FD.get()) != 0)
257 return std::make_pair(Filename,
258 std::error_code(errno, std::generic_category()));
259 Buffers.push_back(std::move(MemberBufferOrErr.get()));
260 MemberRef = Buffers.back()->getMemBufferRef();
262 object::Archive::child_iterator OldMember = Member.getOld();
263 ErrorOr<MemoryBufferRef> MemberBufferOrErr =
264 OldMember->getMemoryBufferRef();
265 if (auto EC = MemberBufferOrErr.getError())
266 return std::make_pair("", EC);
267 MemberRef = MemberBufferOrErr.get();
269 Members.push_back(MemberRef);
272 unsigned MemberReferenceOffset = 0;
274 ErrorOr<unsigned> MemberReferenceOffsetOrErr =
275 writeSymbolTable(Out, NewMembers, Members, MemberOffsetRefs);
276 if (auto EC = MemberReferenceOffsetOrErr.getError())
277 return std::make_pair(ArcName, EC);
278 MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
281 std::vector<unsigned> StringMapIndexes;
282 writeStringTable(Out, NewMembers, StringMapIndexes);
284 unsigned MemberNum = 0;
285 unsigned LongNameMemberNum = 0;
286 unsigned NewMemberNum = 0;
287 std::vector<unsigned> MemberOffset;
288 for (std::vector<NewArchiveIterator>::iterator I = NewMembers.begin(),
289 E = NewMembers.end();
290 I != E; ++I, ++MemberNum) {
292 unsigned Pos = Out.tell();
293 MemberOffset.push_back(Pos);
295 MemoryBufferRef File = Members[MemberNum];
296 if (I->isNewMember()) {
297 StringRef FileName = I->getNew();
298 const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum];
301 StringRef Name = sys::path::filename(FileName);
302 if (Name.size() < 16)
303 printMemberHeader(Out, Name, Status.getLastModificationTime(),
304 Status.getUser(), Status.getGroup(),
305 Status.permissions(), Status.getSize());
307 printMemberHeader(Out, StringMapIndexes[LongNameMemberNum++],
308 Status.getLastModificationTime(), Status.getUser(),
309 Status.getGroup(), Status.permissions(),
312 object::Archive::child_iterator OldMember = I->getOld();
313 StringRef Name = I->getName();
315 if (Name.size() < 16)
316 printMemberHeader(Out, Name, OldMember->getLastModified(),
317 OldMember->getUID(), OldMember->getGID(),
318 OldMember->getAccessMode(), OldMember->getSize());
320 printMemberHeader(Out, StringMapIndexes[LongNameMemberNum++],
321 OldMember->getLastModified(), OldMember->getUID(),
322 OldMember->getGID(), OldMember->getAccessMode(),
323 OldMember->getSize());
326 Out << File.getBuffer();
332 if (MemberReferenceOffset) {
333 Out.seek(MemberReferenceOffset);
334 for (unsigned MemberNum : MemberOffsetRefs)
335 print32BE(Out, MemberOffset[MemberNum]);
340 sys::fs::rename(TmpArchive, ArcName);
341 return std::make_pair("", std::error_code());