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