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