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 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef) 38 : Buf(MemoryBuffer::getMemBuffer(BufRef, false)) {} 39 40 Expected<NewArchiveMember> 41 NewArchiveMember::getOldMember(const object::Archive::Child &OldMember, 42 bool Deterministic) { 43 ErrorOr<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef(); 44 if (!BufOrErr) 45 return errorCodeToError(BufOrErr.getError()); 46 47 NewArchiveMember M; 48 M.Buf = MemoryBuffer::getMemBuffer(*BufOrErr, false); 49 if (!Deterministic) { 50 M.ModTime = OldMember.getLastModified(); 51 M.UID = OldMember.getUID(); 52 M.GID = OldMember.getGID(); 53 M.Perms = OldMember.getAccessMode(); 54 } 55 return std::move(M); 56 } 57 58 Expected<NewArchiveMember> NewArchiveMember::getFile(StringRef FileName, 59 bool Deterministic) { 60 sys::fs::file_status Status; 61 int FD; 62 if (auto EC = sys::fs::openFileForRead(FileName, FD)) 63 return errorCodeToError(EC); 64 assert(FD != -1); 65 66 if (auto EC = sys::fs::status(FD, Status)) 67 return errorCodeToError(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 (Status.type() == sys::fs::file_type::directory_file) 73 return errorCodeToError(make_error_code(errc::is_a_directory)); 74 75 ErrorOr<std::unique_ptr<MemoryBuffer>> MemberBufferOrErr = 76 MemoryBuffer::getOpenFile(FD, FileName, Status.getSize(), false); 77 if (!MemberBufferOrErr) 78 return errorCodeToError(MemberBufferOrErr.getError()); 79 80 if (close(FD) != 0) 81 return errorCodeToError(std::error_code(errno, std::generic_category())); 82 83 NewArchiveMember M; 84 M.Buf = std::move(*MemberBufferOrErr); 85 if (!Deterministic) { 86 M.ModTime = Status.getLastModificationTime(); 87 M.UID = Status.getUser(); 88 M.GID = Status.getGroup(); 89 M.Perms = Status.permissions(); 90 } 91 return std::move(M); 92 } 93 94 template <typename T> 95 static void printWithSpacePadding(raw_fd_ostream &OS, T Data, unsigned Size, 96 bool MayTruncate = false) { 97 uint64_t OldPos = OS.tell(); 98 OS << Data; 99 unsigned SizeSoFar = OS.tell() - OldPos; 100 if (Size > SizeSoFar) { 101 OS.indent(Size - SizeSoFar); 102 } else if (Size < SizeSoFar) { 103 assert(MayTruncate && "Data doesn't fit in Size"); 104 // Some of the data this is used for (like UID) can be larger than the 105 // space available in the archive format. Truncate in that case. 106 OS.seek(OldPos + Size); 107 } 108 } 109 110 static void print32(raw_ostream &Out, object::Archive::Kind Kind, 111 uint32_t Val) { 112 if (Kind == object::Archive::K_GNU) 113 support::endian::Writer<support::big>(Out).write(Val); 114 else 115 support::endian::Writer<support::little>(Out).write(Val); 116 } 117 118 static void printRestOfMemberHeader(raw_fd_ostream &Out, 119 const sys::TimeValue &ModTime, unsigned UID, 120 unsigned GID, unsigned Perms, 121 unsigned Size) { 122 printWithSpacePadding(Out, ModTime.toEpochTime(), 12); 123 printWithSpacePadding(Out, UID, 6, true); 124 printWithSpacePadding(Out, GID, 6, true); 125 printWithSpacePadding(Out, format("%o", Perms), 8); 126 printWithSpacePadding(Out, Size, 10); 127 Out << "`\n"; 128 } 129 130 static void printGNUSmallMemberHeader(raw_fd_ostream &Out, StringRef Name, 131 const sys::TimeValue &ModTime, 132 unsigned UID, unsigned GID, 133 unsigned Perms, unsigned Size) { 134 printWithSpacePadding(Out, Twine(Name) + "/", 16); 135 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); 136 } 137 138 static void printBSDMemberHeader(raw_fd_ostream &Out, StringRef Name, 139 const sys::TimeValue &ModTime, unsigned UID, 140 unsigned GID, unsigned Perms, unsigned Size) { 141 uint64_t PosAfterHeader = Out.tell() + 60 + Name.size(); 142 // Pad so that even 64 bit object files are aligned. 143 unsigned Pad = OffsetToAlignment(PosAfterHeader, 8); 144 unsigned NameWithPadding = Name.size() + Pad; 145 printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16); 146 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, 147 NameWithPadding + Size); 148 Out << Name; 149 assert(PosAfterHeader == Out.tell()); 150 while (Pad--) 151 Out.write(uint8_t(0)); 152 } 153 154 static bool useStringTable(bool Thin, StringRef Name) { 155 return Thin || Name.size() >= 16; 156 } 157 158 static void 159 printMemberHeader(raw_fd_ostream &Out, object::Archive::Kind Kind, bool Thin, 160 StringRef Name, 161 std::vector<unsigned>::iterator &StringMapIndexIter, 162 const sys::TimeValue &ModTime, unsigned UID, unsigned GID, 163 unsigned Perms, unsigned Size) { 164 if (Kind == object::Archive::K_BSD) 165 return printBSDMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size); 166 if (!useStringTable(Thin, Name)) 167 return printGNUSmallMemberHeader(Out, Name, ModTime, UID, GID, Perms, Size); 168 Out << '/'; 169 printWithSpacePadding(Out, *StringMapIndexIter++, 15); 170 printRestOfMemberHeader(Out, ModTime, UID, GID, Perms, Size); 171 } 172 173 // Compute the relative path from From to To. 174 static std::string computeRelativePath(StringRef From, StringRef To) { 175 if (sys::path::is_absolute(From) || sys::path::is_absolute(To)) 176 return To; 177 178 StringRef DirFrom = sys::path::parent_path(From); 179 auto FromI = sys::path::begin(DirFrom); 180 auto ToI = sys::path::begin(To); 181 while (*FromI == *ToI) { 182 ++FromI; 183 ++ToI; 184 } 185 186 SmallString<128> Relative; 187 for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI) 188 sys::path::append(Relative, ".."); 189 190 for (auto ToE = sys::path::end(To); ToI != ToE; ++ToI) 191 sys::path::append(Relative, *ToI); 192 193 return Relative.str(); 194 } 195 196 static void writeStringTable(raw_fd_ostream &Out, StringRef ArcName, 197 ArrayRef<NewArchiveMember> Members, 198 std::vector<unsigned> &StringMapIndexes, 199 bool Thin) { 200 unsigned StartOffset = 0; 201 for (const NewArchiveMember &M : Members) { 202 StringRef Path = M.Buf->getBufferIdentifier(); 203 StringRef Name = sys::path::filename(Path); 204 if (!useStringTable(Thin, Name)) 205 continue; 206 if (StartOffset == 0) { 207 printWithSpacePadding(Out, "//", 58); 208 Out << "`\n"; 209 StartOffset = Out.tell(); 210 } 211 StringMapIndexes.push_back(Out.tell() - StartOffset); 212 213 if (Thin) 214 Out << computeRelativePath(ArcName, Path); 215 else 216 Out << Name; 217 218 Out << "/\n"; 219 } 220 if (StartOffset == 0) 221 return; 222 if (Out.tell() % 2) 223 Out << '\n'; 224 int Pos = Out.tell(); 225 Out.seek(StartOffset - 12); 226 printWithSpacePadding(Out, Pos - StartOffset, 10); 227 Out.seek(Pos); 228 } 229 230 static sys::TimeValue now(bool Deterministic) { 231 if (!Deterministic) 232 return sys::TimeValue::now(); 233 sys::TimeValue TV; 234 TV.fromEpochTime(0); 235 return TV; 236 } 237 238 // Returns the offset of the first reference to a member offset. 239 static ErrorOr<unsigned> 240 writeSymbolTable(raw_fd_ostream &Out, object::Archive::Kind Kind, 241 ArrayRef<NewArchiveMember> Members, 242 std::vector<unsigned> &MemberOffsetRefs, bool Deterministic) { 243 unsigned HeaderStartOffset = 0; 244 unsigned BodyStartOffset = 0; 245 SmallString<128> NameBuf; 246 raw_svector_ostream NameOS(NameBuf); 247 LLVMContext Context; 248 for (unsigned MemberNum = 0, N = Members.size(); MemberNum < N; ++MemberNum) { 249 MemoryBufferRef MemberBuffer = Members[MemberNum].Buf->getMemBufferRef(); 250 Expected<std::unique_ptr<object::SymbolicFile>> ObjOrErr = 251 object::SymbolicFile::createSymbolicFile( 252 MemberBuffer, sys::fs::file_magic::unknown, &Context); 253 if (!ObjOrErr) { 254 // FIXME: check only for "not an object file" errors. 255 consumeError(ObjOrErr.takeError()); 256 continue; 257 } 258 object::SymbolicFile &Obj = *ObjOrErr.get(); 259 260 if (!HeaderStartOffset) { 261 HeaderStartOffset = Out.tell(); 262 if (Kind == object::Archive::K_GNU) 263 printGNUSmallMemberHeader(Out, "", now(Deterministic), 0, 0, 0, 0); 264 else 265 printBSDMemberHeader(Out, "__.SYMDEF", now(Deterministic), 0, 0, 0, 0); 266 BodyStartOffset = Out.tell(); 267 print32(Out, Kind, 0); // number of entries or bytes 268 } 269 270 for (const object::BasicSymbolRef &S : Obj.symbols()) { 271 uint32_t Symflags = S.getFlags(); 272 if (Symflags & object::SymbolRef::SF_FormatSpecific) 273 continue; 274 if (!(Symflags & object::SymbolRef::SF_Global)) 275 continue; 276 if (Symflags & object::SymbolRef::SF_Undefined) 277 continue; 278 279 unsigned NameOffset = NameOS.tell(); 280 if (auto EC = S.printName(NameOS)) 281 return EC; 282 NameOS << '\0'; 283 MemberOffsetRefs.push_back(MemberNum); 284 if (Kind == object::Archive::K_BSD) 285 print32(Out, Kind, NameOffset); 286 print32(Out, Kind, 0); // member offset 287 } 288 } 289 290 if (HeaderStartOffset == 0) 291 return 0; 292 293 StringRef StringTable = NameOS.str(); 294 if (Kind == object::Archive::K_BSD) 295 print32(Out, Kind, StringTable.size()); // byte count of the string table 296 Out << StringTable; 297 298 // ld64 requires the next member header to start at an offset that is 299 // 4 bytes aligned. 300 unsigned Pad = OffsetToAlignment(Out.tell(), 4); 301 while (Pad--) 302 Out.write(uint8_t(0)); 303 304 // Patch up the size of the symbol table now that we know how big it is. 305 unsigned Pos = Out.tell(); 306 const unsigned MemberHeaderSize = 60; 307 Out.seek(HeaderStartOffset + 48); // offset of the size field. 308 printWithSpacePadding(Out, Pos - MemberHeaderSize - HeaderStartOffset, 10); 309 310 // Patch up the number of symbols. 311 Out.seek(BodyStartOffset); 312 unsigned NumSyms = MemberOffsetRefs.size(); 313 if (Kind == object::Archive::K_GNU) 314 print32(Out, Kind, NumSyms); 315 else 316 print32(Out, Kind, NumSyms * 8); 317 318 Out.seek(Pos); 319 return BodyStartOffset + 4; 320 } 321 322 std::pair<StringRef, std::error_code> 323 llvm::writeArchive(StringRef ArcName, 324 std::vector<NewArchiveMember> &NewMembers, 325 bool WriteSymtab, object::Archive::Kind Kind, 326 bool Deterministic, bool Thin, 327 std::unique_ptr<MemoryBuffer> OldArchiveBuf) { 328 assert((!Thin || Kind == object::Archive::K_GNU) && 329 "Only the gnu format has a thin mode"); 330 SmallString<128> TmpArchive; 331 int TmpArchiveFD; 332 if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a", 333 TmpArchiveFD, TmpArchive)) 334 return std::make_pair(ArcName, EC); 335 336 tool_output_file Output(TmpArchive, TmpArchiveFD); 337 raw_fd_ostream &Out = Output.os(); 338 if (Thin) 339 Out << "!<thin>\n"; 340 else 341 Out << "!<arch>\n"; 342 343 std::vector<unsigned> MemberOffsetRefs; 344 345 std::vector<std::unique_ptr<MemoryBuffer>> Buffers; 346 std::vector<MemoryBufferRef> Members; 347 std::vector<sys::fs::file_status> NewMemberStatus; 348 349 unsigned MemberReferenceOffset = 0; 350 if (WriteSymtab) { 351 ErrorOr<unsigned> MemberReferenceOffsetOrErr = writeSymbolTable( 352 Out, Kind, NewMembers, MemberOffsetRefs, Deterministic); 353 if (auto EC = MemberReferenceOffsetOrErr.getError()) 354 return std::make_pair(ArcName, EC); 355 MemberReferenceOffset = MemberReferenceOffsetOrErr.get(); 356 } 357 358 std::vector<unsigned> StringMapIndexes; 359 if (Kind != object::Archive::K_BSD) 360 writeStringTable(Out, ArcName, NewMembers, StringMapIndexes, Thin); 361 362 std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin(); 363 std::vector<unsigned> MemberOffset; 364 for (const NewArchiveMember &M : NewMembers) { 365 MemoryBufferRef File = M.Buf->getMemBufferRef(); 366 367 unsigned Pos = Out.tell(); 368 MemberOffset.push_back(Pos); 369 370 printMemberHeader(Out, Kind, Thin, 371 sys::path::filename(M.Buf->getBufferIdentifier()), 372 StringMapIndexIter, M.ModTime, M.UID, M.GID, M.Perms, 373 M.Buf->getBufferSize()); 374 375 if (!Thin) 376 Out << File.getBuffer(); 377 378 if (Out.tell() % 2) 379 Out << '\n'; 380 } 381 382 if (MemberReferenceOffset) { 383 Out.seek(MemberReferenceOffset); 384 for (unsigned MemberNum : MemberOffsetRefs) { 385 if (Kind == object::Archive::K_BSD) 386 Out.seek(Out.tell() + 4); // skip over the string offset 387 print32(Out, Kind, MemberOffset[MemberNum]); 388 } 389 } 390 391 Output.keep(); 392 Out.close(); 393 394 // At this point, we no longer need whatever backing memory 395 // was used to generate the NewMembers. On Windows, this buffer 396 // could be a mapped view of the file we want to replace (if 397 // we're updating an existing archive, say). In that case, the 398 // rename would still succeed, but it would leave behind a 399 // temporary file (actually the original file renamed) because 400 // a file cannot be deleted while there's a handle open on it, 401 // only renamed. So by freeing this buffer, this ensures that 402 // the last open handle on the destination file, if any, is 403 // closed before we attempt to rename. 404 OldArchiveBuf.reset(); 405 406 sys::fs::rename(TmpArchive, ArcName); 407 return std::make_pair("", std::error_code()); 408 } 409
