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