ArchiveWriter.cpp revision 193323
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 mbr->info = *FSInfo; 172 else 173 return true; 174 175 unsigned flags = 0; 176 bool hasSlash = filePath.toString().find('/') != std::string::npos; 177 if (hasSlash) 178 flags |= ArchiveMember::HasPathFlag; 179 if (hasSlash || filePath.toString().length() > 15) 180 flags |= ArchiveMember::HasLongFilenameFlag; 181 std::string magic; 182 mbr->path.getMagicNumber(magic,4); 183 switch (sys::IdentifyFileType(magic.c_str(),4)) { 184 case sys::Bitcode_FileType: 185 flags |= ArchiveMember::BitcodeFlag; 186 break; 187 default: 188 break; 189 } 190 mbr->flags = flags; 191 members.insert(where,mbr); 192 return false; 193} 194 195// Write one member out to the file. 196bool 197Archive::writeMember( 198 const ArchiveMember& member, 199 std::ofstream& ARFile, 200 bool CreateSymbolTable, 201 bool TruncateNames, 202 bool ShouldCompress, 203 std::string* ErrMsg 204) { 205 206 unsigned filepos = ARFile.tellp(); 207 filepos -= 8; 208 209 // Get the data and its size either from the 210 // member's in-memory data or directly from the file. 211 size_t fSize = member.getSize(); 212 const char *data = (const char*)member.getData(); 213 MemoryBuffer *mFile = 0; 214 if (!data) { 215 mFile = MemoryBuffer::getFile(member.getPath().c_str(), ErrMsg); 216 if (mFile == 0) 217 return true; 218 data = mFile->getBufferStart(); 219 fSize = mFile->getBufferSize(); 220 } 221 222 // Now that we have the data in memory, update the 223 // symbol table if its a bitcode file. 224 if (CreateSymbolTable && member.isBitcode()) { 225 std::vector<std::string> symbols; 226 std::string FullMemberName = archPath.toString() + "(" + 227 member.getPath().toString() 228 + ")"; 229 ModuleProvider* MP = 230 GetBitcodeSymbols((const unsigned char*)data,fSize, 231 FullMemberName, symbols, ErrMsg); 232 233 // If the bitcode parsed successfully 234 if ( MP ) { 235 for (std::vector<std::string>::iterator SI = symbols.begin(), 236 SE = symbols.end(); SI != SE; ++SI) { 237 238 std::pair<SymTabType::iterator,bool> Res = 239 symTab.insert(std::make_pair(*SI,filepos)); 240 241 if (Res.second) { 242 symTabSize += SI->length() + 243 numVbrBytes(SI->length()) + 244 numVbrBytes(filepos); 245 } 246 } 247 // We don't need this module any more. 248 delete MP; 249 } else { 250 delete mFile; 251 if (ErrMsg) 252 *ErrMsg = "Can't parse bitcode member: " + member.getPath().toString() 253 + ": " + *ErrMsg; 254 return true; 255 } 256 } 257 258 int hdrSize = fSize; 259 260 // Compute the fields of the header 261 ArchiveMemberHeader Hdr; 262 bool writeLongName = fillHeader(member,Hdr,hdrSize,TruncateNames); 263 264 // Write header to archive file 265 ARFile.write((char*)&Hdr, sizeof(Hdr)); 266 267 // Write the long filename if its long 268 if (writeLongName) { 269 ARFile.write(member.getPath().toString().data(), 270 member.getPath().toString().length()); 271 } 272 273 // Write the (possibly compressed) member's content to the file. 274 ARFile.write(data,fSize); 275 276 // Make sure the member is an even length 277 if ((ARFile.tellp() & 1) == 1) 278 ARFile << ARFILE_PAD; 279 280 // Close the mapped file if it was opened 281 delete mFile; 282 return false; 283} 284 285// Write out the LLVM symbol table as an archive member to the file. 286void 287Archive::writeSymbolTable(std::ofstream& ARFile) { 288 289 // Construct the symbol table's header 290 ArchiveMemberHeader Hdr; 291 Hdr.init(); 292 memcpy(Hdr.name,ARFILE_LLVM_SYMTAB_NAME,16); 293 uint64_t secondsSinceEpoch = sys::TimeValue::now().toEpochTime(); 294 char buffer[32]; 295 sprintf(buffer, "%-8o", 0644); 296 memcpy(Hdr.mode,buffer,8); 297 sprintf(buffer, "%-6u", sys::Process::GetCurrentUserId()); 298 memcpy(Hdr.uid,buffer,6); 299 sprintf(buffer, "%-6u", sys::Process::GetCurrentGroupId()); 300 memcpy(Hdr.gid,buffer,6); 301 sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch)); 302 memcpy(Hdr.date,buffer,12); 303 sprintf(buffer,"%-10u",symTabSize); 304 memcpy(Hdr.size,buffer,10); 305 306 // Write the header 307 ARFile.write((char*)&Hdr, sizeof(Hdr)); 308 309#ifndef NDEBUG 310 // Save the starting position of the symbol tables data content. 311 unsigned startpos = ARFile.tellp(); 312#endif 313 314 // Write out the symbols sequentially 315 for ( Archive::SymTabType::iterator I = symTab.begin(), E = symTab.end(); 316 I != E; ++I) 317 { 318 // Write out the file index 319 writeInteger(I->second, ARFile); 320 // Write out the length of the symbol 321 writeInteger(I->first.length(), ARFile); 322 // Write out the symbol 323 ARFile.write(I->first.data(), I->first.length()); 324 } 325 326#ifndef NDEBUG 327 // Now that we're done with the symbol table, get the ending file position 328 unsigned endpos = ARFile.tellp(); 329#endif 330 331 // Make sure that the amount we wrote is what we pre-computed. This is 332 // critical for file integrity purposes. 333 assert(endpos - startpos == symTabSize && "Invalid symTabSize computation"); 334 335 // Make sure the symbol table is even sized 336 if (symTabSize % 2 != 0 ) 337 ARFile << ARFILE_PAD; 338} 339 340// Write the entire archive to the file specified when the archive was created. 341// This writes to a temporary file first. Options are for creating a symbol 342// table, flattening the file names (no directories, 15 chars max) and 343// compressing each archive member. 344bool 345Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress, 346 std::string* ErrMsg) 347{ 348 // Make sure they haven't opened up the file, not loaded it, 349 // but are now trying to write it which would wipe out the file. 350 if (members.empty() && mapfile && mapfile->getBufferSize() > 8) { 351 if (ErrMsg) 352 *ErrMsg = "Can't write an archive not opened for writing"; 353 return true; 354 } 355 356 // Create a temporary file to store the archive in 357 sys::Path TmpArchive = archPath; 358 if (TmpArchive.createTemporaryFileOnDisk(ErrMsg)) 359 return true; 360 361 // Make sure the temporary gets removed if we crash 362 sys::RemoveFileOnSignal(TmpArchive); 363 364 // Create archive file for output. 365 std::ios::openmode io_mode = std::ios::out | std::ios::trunc | 366 std::ios::binary; 367 std::ofstream ArchiveFile(TmpArchive.c_str(), io_mode); 368 369 // Check for errors opening or creating archive file. 370 if (!ArchiveFile.is_open() || ArchiveFile.bad()) { 371 if (TmpArchive.exists()) 372 TmpArchive.eraseFromDisk(); 373 if (ErrMsg) 374 *ErrMsg = "Error opening archive file: " + archPath.toString(); 375 return true; 376 } 377 378 // If we're creating a symbol table, reset it now 379 if (CreateSymbolTable) { 380 symTabSize = 0; 381 symTab.clear(); 382 } 383 384 // Write magic string to archive. 385 ArchiveFile << ARFILE_MAGIC; 386 387 // Loop over all member files, and write them out. Note that this also 388 // builds the symbol table, symTab. 389 for (MembersList::iterator I = begin(), E = end(); I != E; ++I) { 390 if (writeMember(*I, ArchiveFile, CreateSymbolTable, 391 TruncateNames, Compress, ErrMsg)) { 392 if (TmpArchive.exists()) 393 TmpArchive.eraseFromDisk(); 394 ArchiveFile.close(); 395 return true; 396 } 397 } 398 399 // Close archive file. 400 ArchiveFile.close(); 401 402 // Write the symbol table 403 if (CreateSymbolTable) { 404 // At this point we have written a file that is a legal archive but it 405 // doesn't have a symbol table in it. To aid in faster reading and to 406 // ensure compatibility with other archivers we need to put the symbol 407 // table first in the file. Unfortunately, this means mapping the file 408 // we just wrote back in and copying it to the destination file. 409 sys::Path FinalFilePath = archPath; 410 411 // Map in the archive we just wrote. 412 { 413 OwningPtr<MemoryBuffer> arch(MemoryBuffer::getFile(TmpArchive.c_str())); 414 if (arch == 0) return true; 415 const char* base = arch->getBufferStart(); 416 417 // Open another temporary file in order to avoid invalidating the 418 // mmapped data 419 if (FinalFilePath.createTemporaryFileOnDisk(ErrMsg)) 420 return true; 421 sys::RemoveFileOnSignal(FinalFilePath); 422 423 std::ofstream FinalFile(FinalFilePath.c_str(), io_mode); 424 if (!FinalFile.is_open() || FinalFile.bad()) { 425 if (TmpArchive.exists()) 426 TmpArchive.eraseFromDisk(); 427 if (ErrMsg) 428 *ErrMsg = "Error opening archive file: " + FinalFilePath.toString(); 429 return true; 430 } 431 432 // Write the file magic number 433 FinalFile << ARFILE_MAGIC; 434 435 // If there is a foreign symbol table, put it into the file now. Most 436 // ar(1) implementations require the symbol table to be first but llvm-ar 437 // can deal with it being after a foreign symbol table. This ensures 438 // compatibility with other ar(1) implementations as well as allowing the 439 // archive to store both native .o and LLVM .bc files, both indexed. 440 if (foreignST) { 441 if (writeMember(*foreignST, FinalFile, false, false, false, ErrMsg)) { 442 FinalFile.close(); 443 if (TmpArchive.exists()) 444 TmpArchive.eraseFromDisk(); 445 return true; 446 } 447 } 448 449 // Put out the LLVM symbol table now. 450 writeSymbolTable(FinalFile); 451 452 // Copy the temporary file contents being sure to skip the file's magic 453 // number. 454 FinalFile.write(base + sizeof(ARFILE_MAGIC)-1, 455 arch->getBufferSize()-sizeof(ARFILE_MAGIC)+1); 456 457 // Close up shop 458 FinalFile.close(); 459 } // free arch. 460 461 // Move the final file over top of TmpArchive 462 if (FinalFilePath.renamePathOnDisk(TmpArchive, ErrMsg)) 463 return true; 464 } 465 466 // Before we replace the actual archive, we need to forget all the 467 // members, since they point to data in that old archive. We need to do 468 // this because we cannot replace an open file on Windows. 469 cleanUpMemory(); 470 471 if (TmpArchive.renamePathOnDisk(archPath, ErrMsg)) 472 return true; 473 474 // Set correct read and write permissions after temporary file is moved 475 // to final destination path. 476 if (archPath.makeReadableOnDisk(ErrMsg)) 477 return true; 478 if (archPath.makeWriteableOnDisk(ErrMsg)) 479 return true; 480 481 return false; 482} 483