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/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"
29 #if !defined(_MSC_VER) && !defined(__MINGW32__)
37 NewArchiveIterator::NewArchiveIterator() {}
39 NewArchiveIterator::NewArchiveIterator(object::Archive::child_iterator I,
41 : IsNewMember(false), Name(Name), OldI(I) {}
43 NewArchiveIterator::NewArchiveIterator(StringRef NewFilename, StringRef Name)
44 : IsNewMember(true), Name(Name), NewFilename(NewFilename) {}
46 StringRef NewArchiveIterator::getName() const { return Name; }
48 bool NewArchiveIterator::isNewMember() const { return IsNewMember; }
50 object::Archive::child_iterator NewArchiveIterator::getOld() const {
55 StringRef NewArchiveIterator::getNew() const {
61 NewArchiveIterator::getFD(sys::fs::file_status &NewStatus) const {
64 if (auto EC = sys::fs::openFileForRead(NewFilename, NewFD))
68 if (auto EC = sys::fs::status(NewFD, NewStatus))
71 // Opening a directory doesn't make sense. Let it fail.
72 // Linux cannot open directories with open(2), although
73 // cygwin and *bsd can.
74 if (NewStatus.type() == sys::fs::file_type::directory_file)
75 return make_error_code(errc::is_a_directory);
81 static void printWithSpacePadding(raw_fd_ostream &OS, T Data, unsigned Size,
82 bool MayTruncate = false) {
83 uint64_t OldPos = OS.tell();
85 unsigned SizeSoFar = OS.tell() - OldPos;
86 if (Size > SizeSoFar) {
87 OS.indent(Size - SizeSoFar);
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_ostream &Out, uint32_t Val) {
97 support::endian::Writer<support::big>(Out).write(Val);
100 static void printRestOfMemberHeader(raw_fd_ostream &Out,
101 const sys::TimeValue &ModTime, unsigned UID,
102 unsigned GID, unsigned Perms,
104 printWithSpacePadding(Out, ModTime.toEpochTime(), 12);
105 printWithSpacePadding(Out, UID, 6, true);
106 printWithSpacePadding(Out, GID, 6, true);
107 printWithSpacePadding(Out, format("%o", Perms), 8);
108 printWithSpacePadding(Out, Size, 10);
112 static void printMemberHeader(raw_fd_ostream &Out, StringRef Name,
113 const sys::TimeValue &ModTime, unsigned UID,
114 unsigned GID, unsigned Perms, unsigned Size) {
115 printWithSpacePadding(Out, Twine(Name) + "/", 16);
116 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
119 static void printMemberHeader(raw_fd_ostream &Out, unsigned NameOffset,
120 const sys::TimeValue &ModTime, unsigned UID,
121 unsigned GID, unsigned Perms, unsigned Size) {
123 printWithSpacePadding(Out, NameOffset, 15);
124 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size);
128 printMemberHeader(raw_fd_ostream &Out, StringRef Name,
129 std::vector<unsigned>::iterator &StringMapIndexIter,
130 const sys::TimeValue &ModTime, unsigned UID, unsigned GID,
131 unsigned Perms, unsigned Size) {
132 if (Name.size() < 16)
133 printMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size);
135 printMemberHeader(Out, *StringMapIndexIter++, ModTime, UID, GID, Perms,
139 static void writeStringTable(raw_fd_ostream &Out,
140 ArrayRef<NewArchiveIterator> Members,
141 std::vector<unsigned> &StringMapIndexes) {
142 unsigned StartOffset = 0;
143 for (ArrayRef<NewArchiveIterator>::iterator I = Members.begin(),
146 StringRef Name = I->getName();
147 if (Name.size() < 16)
149 if (StartOffset == 0) {
150 printWithSpacePadding(Out, "//", 58);
152 StartOffset = Out.tell();
154 StringMapIndexes.push_back(Out.tell() - StartOffset);
155 Out << Name << "/\n";
157 if (StartOffset == 0)
161 int Pos = Out.tell();
162 Out.seek(StartOffset - 12);
163 printWithSpacePadding(Out, Pos - StartOffset, 10);
167 // Returns the offset of the first reference to a member offset.
168 static ErrorOr<unsigned>
169 writeSymbolTable(raw_fd_ostream &Out, ArrayRef<NewArchiveIterator> Members,
170 ArrayRef<MemoryBufferRef> Buffers,
171 std::vector<unsigned> &MemberOffsetRefs) {
172 unsigned StartOffset = 0;
173 unsigned MemberNum = 0;
175 raw_string_ostream NameOS(NameBuf);
176 unsigned NumSyms = 0;
178 for (ArrayRef<NewArchiveIterator>::iterator I = Members.begin(),
180 I != E; ++I, ++MemberNum) {
181 MemoryBufferRef MemberBuffer = Buffers[MemberNum];
182 ErrorOr<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
183 object::SymbolicFile::createSymbolicFile(
184 MemberBuffer, sys::fs::file_magic::unknown, &Context);
186 continue; // FIXME: check only for "not an object file" errors.
187 object::SymbolicFile &Obj = *ObjOrErr.get();
190 printMemberHeader(Out, "", sys::TimeValue::now(), 0, 0, 0, 0);
191 StartOffset = Out.tell();
195 for (const object::BasicSymbolRef &S : Obj.symbols()) {
196 uint32_t Symflags = S.getFlags();
197 if (Symflags & object::SymbolRef::SF_FormatSpecific)
199 if (!(Symflags & object::SymbolRef::SF_Global))
201 if (Symflags & object::SymbolRef::SF_Undefined)
203 if (auto EC = S.printName(NameOS))
207 MemberOffsetRefs.push_back(MemberNum);
213 if (StartOffset == 0)
219 unsigned Pos = Out.tell();
220 Out.seek(StartOffset - 12);
221 printWithSpacePadding(Out, Pos - StartOffset, 10);
222 Out.seek(StartOffset);
223 print32BE(Out, NumSyms);
225 return StartOffset + 4;
228 std::pair<StringRef, std::error_code>
229 llvm::writeArchive(StringRef ArcName,
230 std::vector<NewArchiveIterator> &NewMembers,
232 SmallString<128> TmpArchive;
234 if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
235 TmpArchiveFD, TmpArchive))
236 return std::make_pair(ArcName, EC);
238 tool_output_file Output(TmpArchive, TmpArchiveFD);
239 raw_fd_ostream &Out = Output.os();
242 std::vector<unsigned> MemberOffsetRefs;
244 std::vector<std::unique_ptr<MemoryBuffer>> Buffers;
245 std::vector<MemoryBufferRef> Members;
246 std::vector<sys::fs::file_status> NewMemberStatus;
248 for (unsigned I = 0, N = NewMembers.size(); I < N; ++I) {
249 NewArchiveIterator &Member = NewMembers[I];
250 MemoryBufferRef MemberRef;
252 if (Member.isNewMember()) {
253 StringRef Filename = Member.getNew();
254 NewMemberStatus.resize(NewMemberStatus.size() + 1);
255 sys::fs::file_status &Status = NewMemberStatus.back();
256 ErrorOr<int> FD = Member.getFD(Status);
257 if (auto EC = FD.getError())
258 return std::make_pair(Filename, EC);
259 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr =
260 MemoryBuffer::getOpenFile(FD.get(), Filename, Status.getSize(),
262 if (auto EC = MemberBufferOrErr.getError())
263 return std::make_pair(Filename, EC);
264 if (close(FD.get()) != 0)
265 return std::make_pair(Filename,
266 std::error_code(errno, std::generic_category()));
267 Buffers.push_back(std::move(MemberBufferOrErr.get()));
268 MemberRef = Buffers.back()->getMemBufferRef();
270 object::Archive::child_iterator OldMember = Member.getOld();
271 ErrorOr<MemoryBufferRef> MemberBufferOrErr =
272 OldMember->getMemoryBufferRef();
273 if (auto EC = MemberBufferOrErr.getError())
274 return std::make_pair("", EC);
275 MemberRef = MemberBufferOrErr.get();
277 Members.push_back(MemberRef);
280 unsigned MemberReferenceOffset = 0;
282 ErrorOr<unsigned> MemberReferenceOffsetOrErr =
283 writeSymbolTable(Out, NewMembers, Members, MemberOffsetRefs);
284 if (auto EC = MemberReferenceOffsetOrErr.getError())
285 return std::make_pair(ArcName, EC);
286 MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
289 std::vector<unsigned> StringMapIndexes;
290 writeStringTable(Out, NewMembers, StringMapIndexes);
292 unsigned MemberNum = 0;
293 unsigned NewMemberNum = 0;
294 std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin();
295 std::vector<unsigned> MemberOffset;
296 for (const NewArchiveIterator &I : NewMembers) {
297 MemoryBufferRef File = Members[MemberNum++];
299 unsigned Pos = Out.tell();
300 MemberOffset.push_back(Pos);
302 if (I.isNewMember()) {
303 StringRef FileName = I.getNew();
304 const sys::fs::file_status &Status = NewMemberStatus[NewMemberNum++];
305 printMemberHeader(Out, sys::path::filename(FileName), StringMapIndexIter,
306 Status.getLastModificationTime(), Status.getUser(),
307 Status.getGroup(), Status.permissions(),
310 object::Archive::child_iterator OldMember = I.getOld();
311 printMemberHeader(Out, I.getName(), StringMapIndexIter,
312 OldMember->getLastModified(), OldMember->getUID(),
313 OldMember->getGID(), OldMember->getAccessMode(),
314 OldMember->getSize());
317 Out << File.getBuffer();
323 if (MemberReferenceOffset) {
324 Out.seek(MemberReferenceOffset);
325 for (unsigned MemberNum : MemberOffsetRefs)
326 print32BE(Out, MemberOffset[MemberNum]);
331 sys::fs::rename(TmpArchive, ArcName);
332 return std::make_pair("", std::error_code());