1 //===-- ArchiveWriter.cpp - Write LLVM archive files ----------------------===// 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 // Builds up an LLVM archive file (.a) containing LLVM bitcode. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Bitcode/Archive.h" 15 #include "ArchiveInternals.h" 16 #include "llvm/ADT/OwningPtr.h" 17 #include "llvm/Bitcode/ReaderWriter.h" 18 #include "llvm/IR/Module.h" 19 #include "llvm/Support/FileSystem.h" 20 #include "llvm/Support/MemoryBuffer.h" 21 #include "llvm/Support/Process.h" 22 #include "llvm/Support/Signals.h" 23 #include "llvm/Support/system_error.h" 24 #include <fstream> 25 #include <iomanip> 26 #include <ostream> 27 using namespace llvm; 28 29 // Write an integer using variable bit rate encoding. This saves a few bytes 30 // per entry in the symbol table. 31 static inline void writeInteger(unsigned num, std::ofstream& ARFile) { 32 while (1) { 33 if (num < 0x80) { // done? 34 ARFile << (unsigned char)num; 35 return; 36 } 37 38 // Nope, we are bigger than a character, output the next 7 bits and set the 39 // high bit to say that there is more coming... 40 ARFile << (unsigned char)(0x80 | ((unsigned char)num & 0x7F)); 41 num >>= 7; // Shift out 7 bits now... 42 } 43 } 44 45 // Compute how many bytes are taken by a given VBR encoded value. This is needed 46 // to pre-compute the size of the symbol table. 47 static inline unsigned numVbrBytes(unsigned num) { 48 49 // Note that the following nested ifs are somewhat equivalent to a binary 50 // search. We split it in half by comparing against 2^14 first. This allows 51 // most reasonable values to be done in 2 comparisons instead of 1 for 52 // small ones and four for large ones. We expect this to access file offsets 53 // in the 2^10 to 2^24 range and symbol lengths in the 2^0 to 2^8 range, 54 // so this approach is reasonable. 55 if (num < 1<<14) { 56 if (num < 1<<7) 57 return 1; 58 else 59 return 2; 60 } 61 if (num < 1<<21) 62 return 3; 63 64 if (num < 1<<28) 65 return 4; 66 return 5; // anything >= 2^28 takes 5 bytes 67 } 68 69 // Create an empty archive. 70 Archive* Archive::CreateEmpty(const sys::Path& FilePath, LLVMContext& C) { 71 Archive* result = new Archive(FilePath, C); 72 return result; 73 } 74 75 // Fill the ArchiveMemberHeader with the information from a member. If 76 // TruncateNames is true, names are flattened to 15 chars or less. The sz field 77 // is provided here instead of coming from the mbr because the member might be 78 // stored compressed and the compressed size is not the ArchiveMember's size. 79 // Furthermore compressed files have negative size fields to identify them as 80 // compressed. 81 bool 82 Archive::fillHeader(const ArchiveMember &mbr, ArchiveMemberHeader& hdr, 83 int sz, bool TruncateNames) const { 84 85 // Set the permissions mode, uid and gid 86 hdr.init(); 87 char buffer[32]; 88 sprintf(buffer, "%-8o", mbr.getMode()); 89 memcpy(hdr.mode,buffer,8); 90 sprintf(buffer, "%-6u", mbr.getUser()); 91 memcpy(hdr.uid,buffer,6); 92 sprintf(buffer, "%-6u", mbr.getGroup()); 93 memcpy(hdr.gid,buffer,6); 94 95 // Set the last modification date 96 uint64_t secondsSinceEpoch = mbr.getModTime().toEpochTime(); 97 sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch)); 98 memcpy(hdr.date,buffer,12); 99 100 // Get rid of trailing blanks in the name 101 std::string mbrPath = mbr.getPath().str(); 102 size_t mbrLen = mbrPath.length(); 103 while (mbrLen > 0 && mbrPath[mbrLen-1] == ' ') { 104 mbrPath.erase(mbrLen-1,1); 105 mbrLen--; 106 } 107 108 // Set the name field in one of its various flavors. 109 bool writeLongName = false; 110 if (mbr.isStringTable()) { 111 memcpy(hdr.name,ARFILE_STRTAB_NAME,16); 112 } else if (mbr.isSVR4SymbolTable()) { 113 memcpy(hdr.name,ARFILE_SVR4_SYMTAB_NAME,16); 114 } else if (mbr.isBSD4SymbolTable()) { 115 memcpy(hdr.name,ARFILE_BSD4_SYMTAB_NAME,16); 116 } else if (mbr.isLLVMSymbolTable()) { 117 memcpy(hdr.name,ARFILE_LLVM_SYMTAB_NAME,16); 118 } else if (TruncateNames) { 119 const char* nm = mbrPath.c_str(); 120 unsigned len = mbrPath.length(); 121 size_t slashpos = mbrPath.rfind('/'); 122 if (slashpos != std::string::npos) { 123 nm += slashpos + 1; 124 len -= slashpos +1; 125 } 126 if (len > 15) 127 len = 15; 128 memcpy(hdr.name,nm,len); 129 hdr.name[len] = '/'; 130 } else if (mbrPath.length() < 16 && mbrPath.find('/') == std::string::npos) { 131 memcpy(hdr.name,mbrPath.c_str(),mbrPath.length()); 132 hdr.name[mbrPath.length()] = '/'; 133 } else { 134 std::string nm = "#1/"; 135 nm += utostr(mbrPath.length()); 136 memcpy(hdr.name,nm.data(),nm.length()); 137 if (sz < 0) 138 sz -= mbrPath.length(); 139 else 140 sz += mbrPath.length(); 141 writeLongName = true; 142 } 143 144 // Set the size field 145 if (sz < 0) { 146 buffer[0] = '-'; 147 sprintf(&buffer[1],"%-9u",(unsigned)-sz); 148 } else { 149 sprintf(buffer, "%-10u", (unsigned)sz); 150 } 151 memcpy(hdr.size,buffer,10); 152 153 return writeLongName; 154 } 155 156 // Insert a file into the archive before some other member. This also takes care 157 // of extracting the necessary flags and information from the file. 158 bool 159 Archive::addFileBefore(const sys::Path& filePath, iterator where, 160 std::string* ErrMsg) { 161 bool Exists; 162 if (sys::fs::exists(filePath.str(), Exists) || !Exists) { 163 if (ErrMsg) 164 *ErrMsg = "Can not add a non-existent file to archive"; 165 return true; 166 } 167 168 ArchiveMember* mbr = new ArchiveMember(this); 169 170 mbr->data = 0; 171 mbr->path = filePath; 172 const sys::FileStatus *FSInfo = mbr->path.getFileStatus(false, ErrMsg); 173 if (!FSInfo) { 174 delete mbr; 175 return true; 176 } 177 mbr->info = *FSInfo; 178 179 unsigned flags = 0; 180 bool hasSlash = filePath.str().find('/') != std::string::npos; 181 if (hasSlash) 182 flags |= ArchiveMember::HasPathFlag; 183 if (hasSlash || filePath.str().length() > 15) 184 flags |= ArchiveMember::HasLongFilenameFlag; 185 186 sys::fs::file_magic type; 187 if (sys::fs::identify_magic(mbr->path.str(), type)) 188 type = sys::fs::file_magic::unknown; 189 switch (type) { 190 case sys::fs::file_magic::bitcode: 191 flags |= ArchiveMember::BitcodeFlag; 192 break; 193 default: 194 break; 195 } 196 mbr->flags = flags; 197 members.insert(where,mbr); 198 return false; 199 } 200 201 // Write one member out to the file. 202 bool 203 Archive::writeMember( 204 const ArchiveMember& member, 205 std::ofstream& ARFile, 206 bool CreateSymbolTable, 207 bool TruncateNames, 208 std::string* ErrMsg 209 ) { 210 211 unsigned filepos = ARFile.tellp(); 212 filepos -= 8; 213 214 // Get the data and its size either from the 215 // member's in-memory data or directly from the file. 216 size_t fSize = member.getSize(); 217 const char *data = (const char*)member.getData(); 218 MemoryBuffer *mFile = 0; 219 if (!data) { 220 OwningPtr<MemoryBuffer> File; 221 if (error_code ec = MemoryBuffer::getFile(member.getPath().c_str(), File)) { 222 if (ErrMsg) 223 *ErrMsg = ec.message(); 224 return true; 225 } 226 mFile = File.take(); 227 data = mFile->getBufferStart(); 228 fSize = mFile->getBufferSize(); 229 } 230 231 // Now that we have the data in memory, update the 232 // symbol table if it's a bitcode file. 233 if (CreateSymbolTable && member.isBitcode()) { 234 std::vector<std::string> symbols; 235 std::string FullMemberName = archPath.str() + "(" + member.getPath().str() 236 + ")"; 237 Module* M = 238 GetBitcodeSymbols(data, fSize, FullMemberName, Context, symbols, ErrMsg); 239 240 // If the bitcode parsed successfully 241 if ( M ) { 242 for (std::vector<std::string>::iterator SI = symbols.begin(), 243 SE = symbols.end(); SI != SE; ++SI) { 244 245 std::pair<SymTabType::iterator,bool> Res = 246 symTab.insert(std::make_pair(*SI,filepos)); 247 248 if (Res.second) { 249 symTabSize += SI->length() + 250 numVbrBytes(SI->length()) + 251 numVbrBytes(filepos); 252 } 253 } 254 // We don't need this module any more. 255 delete M; 256 } else { 257 delete mFile; 258 if (ErrMsg) 259 *ErrMsg = "Can't parse bitcode member: " + member.getPath().str() 260 + ": " + *ErrMsg; 261 return true; 262 } 263 } 264 265 int hdrSize = fSize; 266 267 // Compute the fields of the header 268 ArchiveMemberHeader Hdr; 269 bool writeLongName = fillHeader(member,Hdr,hdrSize,TruncateNames); 270 271 // Write header to archive file 272 ARFile.write((char*)&Hdr, sizeof(Hdr)); 273 274 // Write the long filename if its long 275 if (writeLongName) { 276 ARFile.write(member.getPath().str().data(), 277 member.getPath().str().length()); 278 } 279 280 // Write the (possibly compressed) member's content to the file. 281 ARFile.write(data,fSize); 282 283 // Make sure the member is an even length 284 if ((ARFile.tellp() & 1) == 1) 285 ARFile << ARFILE_PAD; 286 287 // Close the mapped file if it was opened 288 delete mFile; 289 return false; 290 } 291 292 // Write out the LLVM symbol table as an archive member to the file. 293 void 294 Archive::writeSymbolTable(std::ofstream& ARFile) { 295 296 // Construct the symbol table's header 297 ArchiveMemberHeader Hdr; 298 Hdr.init(); 299 memcpy(Hdr.name,ARFILE_LLVM_SYMTAB_NAME,16); 300 uint64_t secondsSinceEpoch = sys::TimeValue::now().toEpochTime(); 301 char buffer[32]; 302 sprintf(buffer, "%-8o", 0644); 303 memcpy(Hdr.mode,buffer,8); 304 sprintf(buffer, "%-6u", sys::Process::GetCurrentUserId()); 305 memcpy(Hdr.uid,buffer,6); 306 sprintf(buffer, "%-6u", sys::Process::GetCurrentGroupId()); 307 memcpy(Hdr.gid,buffer,6); 308 sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch)); 309 memcpy(Hdr.date,buffer,12); 310 sprintf(buffer,"%-10u",symTabSize); 311 memcpy(Hdr.size,buffer,10); 312 313 // Write the header 314 ARFile.write((char*)&Hdr, sizeof(Hdr)); 315 316 #ifndef NDEBUG 317 // Save the starting position of the symbol tables data content. 318 unsigned startpos = ARFile.tellp(); 319 #endif 320 321 // Write out the symbols sequentially 322 for ( Archive::SymTabType::iterator I = symTab.begin(), E = symTab.end(); 323 I != E; ++I) 324 { 325 // Write out the file index 326 writeInteger(I->second, ARFile); 327 // Write out the length of the symbol 328 writeInteger(I->first.length(), ARFile); 329 // Write out the symbol 330 ARFile.write(I->first.data(), I->first.length()); 331 } 332 333 #ifndef NDEBUG 334 // Now that we're done with the symbol table, get the ending file position 335 unsigned endpos = ARFile.tellp(); 336 #endif 337 338 // Make sure that the amount we wrote is what we pre-computed. This is 339 // critical for file integrity purposes. 340 assert(endpos - startpos == symTabSize && "Invalid symTabSize computation"); 341 342 // Make sure the symbol table is even sized 343 if (symTabSize % 2 != 0 ) 344 ARFile << ARFILE_PAD; 345 } 346 347 // Write the entire archive to the file specified when the archive was created. 348 // This writes to a temporary file first. Options are for creating a symbol 349 // table, flattening the file names (no directories, 15 chars max) and 350 // compressing each archive member. 351 bool 352 Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, 353 std::string* ErrMsg) 354 { 355 // Make sure they haven't opened up the file, not loaded it, 356 // but are now trying to write it which would wipe out the file. 357 if (members.empty() && mapfile && mapfile->getBufferSize() > 8) { 358 if (ErrMsg) 359 *ErrMsg = "Can't write an archive not opened for writing"; 360 return true; 361 } 362 363 // Create a temporary file to store the archive in 364 sys::Path TmpArchive = archPath; 365 if (TmpArchive.createTemporaryFileOnDisk(ErrMsg)) 366 return true; 367 368 // Make sure the temporary gets removed if we crash 369 sys::RemoveFileOnSignal(TmpArchive); 370 371 // Create archive file for output. 372 std::ios::openmode io_mode = std::ios::out | std::ios::trunc | 373 std::ios::binary; 374 std::ofstream ArchiveFile(TmpArchive.c_str(), io_mode); 375 376 // Check for errors opening or creating archive file. 377 if (!ArchiveFile.is_open() || ArchiveFile.bad()) { 378 TmpArchive.eraseFromDisk(); 379 if (ErrMsg) 380 *ErrMsg = "Error opening archive file: " + archPath.str(); 381 return true; 382 } 383 384 // If we're creating a symbol table, reset it now 385 if (CreateSymbolTable) { 386 symTabSize = 0; 387 symTab.clear(); 388 } 389 390 // Write magic string to archive. 391 ArchiveFile << ARFILE_MAGIC; 392 393 // Loop over all member files, and write them out. Note that this also 394 // builds the symbol table, symTab. 395 for (MembersList::iterator I = begin(), E = end(); I != E; ++I) { 396 if (writeMember(*I, ArchiveFile, CreateSymbolTable, 397 TruncateNames, ErrMsg)) { 398 TmpArchive.eraseFromDisk(); 399 ArchiveFile.close(); 400 return true; 401 } 402 } 403 404 // Close archive file. 405 ArchiveFile.close(); 406 407 // Write the symbol table 408 if (CreateSymbolTable) { 409 // At this point we have written a file that is a legal archive but it 410 // doesn't have a symbol table in it. To aid in faster reading and to 411 // ensure compatibility with other archivers we need to put the symbol 412 // table first in the file. Unfortunately, this means mapping the file 413 // we just wrote back in and copying it to the destination file. 414 sys::Path FinalFilePath = archPath; 415 416 // Map in the archive we just wrote. 417 { 418 OwningPtr<MemoryBuffer> arch; 419 if (error_code ec = MemoryBuffer::getFile(TmpArchive.c_str(), arch)) { 420 if (ErrMsg) 421 *ErrMsg = ec.message(); 422 return true; 423 } 424 const char* base = arch->getBufferStart(); 425 426 // Open another temporary file in order to avoid invalidating the 427 // mmapped data 428 if (FinalFilePath.createTemporaryFileOnDisk(ErrMsg)) 429 return true; 430 sys::RemoveFileOnSignal(FinalFilePath); 431 432 std::ofstream FinalFile(FinalFilePath.c_str(), io_mode); 433 if (!FinalFile.is_open() || FinalFile.bad()) { 434 TmpArchive.eraseFromDisk(); 435 if (ErrMsg) 436 *ErrMsg = "Error opening archive file: " + FinalFilePath.str(); 437 return true; 438 } 439 440 // Write the file magic number 441 FinalFile << ARFILE_MAGIC; 442 443 // If there is a foreign symbol table, put it into the file now. Most 444 // ar(1) implementations require the symbol table to be first but llvm-ar 445 // can deal with it being after a foreign symbol table. This ensures 446 // compatibility with other ar(1) implementations as well as allowing the 447 // archive to store both native .o and LLVM .bc files, both indexed. 448 if (foreignST) { 449 if (writeMember(*foreignST, FinalFile, false, false, ErrMsg)) { 450 FinalFile.close(); 451 TmpArchive.eraseFromDisk(); 452 return true; 453 } 454 } 455 456 // Put out the LLVM symbol table now. 457 writeSymbolTable(FinalFile); 458 459 // Copy the temporary file contents being sure to skip the file's magic 460 // number. 461 FinalFile.write(base + sizeof(ARFILE_MAGIC)-1, 462 arch->getBufferSize()-sizeof(ARFILE_MAGIC)+1); 463 464 // Close up shop 465 FinalFile.close(); 466 } // free arch. 467 468 // Move the final file over top of TmpArchive 469 if (FinalFilePath.renamePathOnDisk(TmpArchive, ErrMsg)) 470 return true; 471 } 472 473 // Before we replace the actual archive, we need to forget all the 474 // members, since they point to data in that old archive. We need to do 475 // this because we cannot replace an open file on Windows. 476 cleanUpMemory(); 477 478 if (TmpArchive.renamePathOnDisk(archPath, ErrMsg)) 479 return true; 480 481 // Set correct read and write permissions after temporary file is moved 482 // to final destination path. 483 if (archPath.makeReadableOnDisk(ErrMsg)) 484 return true; 485 if (archPath.makeWriteableOnDisk(ErrMsg)) 486 return true; 487 488 return false; 489 } 490