Remove attribution from file headers, per discussion on llvmdev.
[oota-llvm.git] / lib / Archive / ArchiveWriter.cpp
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/System/Signals.h"
17 #include "llvm/System/Process.h"
18 #include "llvm/ModuleProvider.h"
19 #include <fstream>
20 #include <ostream>
21 #include <iomanip>
22 using namespace llvm;
23
24 // Write an integer using variable bit rate encoding. This saves a few bytes
25 // per entry in the symbol table.
26 inline void writeInteger(unsigned num, std::ofstream& ARFile) {
27   while (1) {
28     if (num < 0x80) { // done?
29       ARFile << (unsigned char)num;
30       return;
31     }
32
33     // Nope, we are bigger than a character, output the next 7 bits and set the
34     // high bit to say that there is more coming...
35     ARFile << (unsigned char)(0x80 | ((unsigned char)num & 0x7F));
36     num >>= 7;  // Shift out 7 bits now...
37   }
38 }
39
40 // Compute how many bytes are taken by a given VBR encoded value. This is needed
41 // to pre-compute the size of the symbol table.
42 inline unsigned numVbrBytes(unsigned num) {
43
44   // Note that the following nested ifs are somewhat equivalent to a binary
45   // search. We split it in half by comparing against 2^14 first. This allows
46   // most reasonable values to be done in 2 comparisons instead of 1 for
47   // small ones and four for large ones. We expect this to access file offsets
48   // in the 2^10 to 2^24 range and symbol lengths in the 2^0 to 2^8 range,
49   // so this approach is reasonable.
50   if (num < 1<<14)
51     if (num < 1<<7)
52       return 1;
53     else
54       return 2;
55   if (num < 1<<21)
56     return 3;
57
58   if (num < 1<<28)
59     return 4;
60   return 5; // anything >= 2^28 takes 5 bytes
61 }
62
63 // Create an empty archive.
64 Archive*
65 Archive::CreateEmpty(const sys::Path& FilePath ) {
66   Archive* result = new Archive(FilePath);
67   return result;
68 }
69
70 // Fill the ArchiveMemberHeader with the information from a member. If
71 // TruncateNames is true, names are flattened to 15 chars or less. The sz field
72 // is provided here instead of coming from the mbr because the member might be
73 // stored compressed and the compressed size is not the ArchiveMember's size.
74 // Furthermore compressed files have negative size fields to identify them as
75 // compressed.
76 bool
77 Archive::fillHeader(const ArchiveMember &mbr, ArchiveMemberHeader& hdr,
78                     int sz, bool TruncateNames) const {
79
80   // Set the permissions mode, uid and gid
81   hdr.init();
82   char buffer[32];
83   sprintf(buffer, "%-8o", mbr.getMode());
84   memcpy(hdr.mode,buffer,8);
85   sprintf(buffer,  "%-6u", mbr.getUser());
86   memcpy(hdr.uid,buffer,6);
87   sprintf(buffer,  "%-6u", mbr.getGroup());
88   memcpy(hdr.gid,buffer,6);
89
90   // Set the last modification date
91   uint64_t secondsSinceEpoch = mbr.getModTime().toEpochTime();
92   sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch));
93   memcpy(hdr.date,buffer,12);
94
95   // Get rid of trailing blanks in the name
96   std::string mbrPath = mbr.getPath().toString();
97   size_t mbrLen = mbrPath.length();
98   while (mbrLen > 0 && mbrPath[mbrLen-1] == ' ') {
99     mbrPath.erase(mbrLen-1,1);
100     mbrLen--;
101   }
102
103   // Set the name field in one of its various flavors.
104   bool writeLongName = false;
105   if (mbr.isStringTable()) {
106     memcpy(hdr.name,ARFILE_STRTAB_NAME,16);
107   } else if (mbr.isSVR4SymbolTable()) {
108     memcpy(hdr.name,ARFILE_SVR4_SYMTAB_NAME,16);
109   } else if (mbr.isBSD4SymbolTable()) {
110     memcpy(hdr.name,ARFILE_BSD4_SYMTAB_NAME,16);
111   } else if (mbr.isLLVMSymbolTable()) {
112     memcpy(hdr.name,ARFILE_LLVM_SYMTAB_NAME,16);
113   } else if (TruncateNames) {
114     const char* nm = mbrPath.c_str();
115     unsigned len = mbrPath.length();
116     size_t slashpos = mbrPath.rfind('/');
117     if (slashpos != std::string::npos) {
118       nm += slashpos + 1;
119       len -= slashpos +1;
120     }
121     if (len > 15)
122       len = 15;
123     memcpy(hdr.name,nm,len);
124     hdr.name[len] = '/';
125   } else if (mbrPath.length() < 16 && mbrPath.find('/') == std::string::npos) {
126     memcpy(hdr.name,mbrPath.c_str(),mbrPath.length());
127     hdr.name[mbrPath.length()] = '/';
128   } else {
129     std::string nm = "#1/";
130     nm += utostr(mbrPath.length());
131     memcpy(hdr.name,nm.data(),nm.length());
132     if (sz < 0)
133       sz -= mbrPath.length();
134     else
135       sz += mbrPath.length();
136     writeLongName = true;
137   }
138
139   // Set the size field
140   if (sz < 0) {
141     buffer[0] = '-';
142     sprintf(&buffer[1],"%-9u",(unsigned)-sz);
143   } else {
144     sprintf(buffer, "%-10u", (unsigned)sz);
145   }
146   memcpy(hdr.size,buffer,10);
147
148   return writeLongName;
149 }
150
151 // Insert a file into the archive before some other member. This also takes care
152 // of extracting the necessary flags and information from the file.
153 bool
154 Archive::addFileBefore(const sys::Path& filePath, iterator where, 
155                         std::string* ErrMsg) {
156   if (!filePath.exists()) {
157     if (ErrMsg)
158       *ErrMsg = "Can not add a non-existent file to archive";
159     return true;
160   }
161
162   ArchiveMember* mbr = new ArchiveMember(this);
163
164   mbr->data = 0;
165   mbr->path = filePath;
166   const sys::FileStatus *FSInfo = mbr->path.getFileStatus(false, ErrMsg);
167   if (FSInfo)
168     mbr->info = *FSInfo;
169   else
170     return true;
171
172   unsigned flags = 0;
173   bool hasSlash = filePath.toString().find('/') != std::string::npos;
174   if (hasSlash)
175     flags |= ArchiveMember::HasPathFlag;
176   if (hasSlash || filePath.toString().length() > 15)
177     flags |= ArchiveMember::HasLongFilenameFlag;
178   std::string magic;
179   mbr->path.getMagicNumber(magic,4);
180   switch (sys::IdentifyFileType(magic.c_str(),4)) {
181     case sys::Bitcode_FileType:
182       flags |= ArchiveMember::BitcodeFlag;
183       break;
184     default:
185       break;
186   }
187   mbr->flags = flags;
188   members.insert(where,mbr);
189   return false;
190 }
191
192 // Write one member out to the file.
193 bool
194 Archive::writeMember(
195   const ArchiveMember& member,
196   std::ofstream& ARFile,
197   bool CreateSymbolTable,
198   bool TruncateNames,
199   bool ShouldCompress,
200   std::string* ErrMsg
201 ) {
202
203   unsigned filepos = ARFile.tellp();
204   filepos -= 8;
205
206   // Get the data and its size either from the
207   // member's in-memory data or directly from the file.
208   size_t fSize = member.getSize();
209   const char* data = (const char*)member.getData();
210   sys::MappedFile* mFile = 0;
211   if (!data) {
212     mFile = new sys::MappedFile();
213     if (mFile->open(member.getPath(), sys::MappedFile::READ_ACCESS, ErrMsg))
214       return true;
215     if (!(data = (const char*) mFile->map(ErrMsg)))
216       return true;
217     fSize = mFile->size();
218   }
219
220   // Now that we have the data in memory, update the
221   // symbol table if its a bitcode file.
222   if (CreateSymbolTable && member.isBitcode()) {
223     std::vector<std::string> symbols;
224     std::string FullMemberName = archPath.toString() + "(" +
225       member.getPath().toString()
226       + ")";
227     ModuleProvider* MP = 
228       GetBitcodeSymbols((const unsigned char*)data,fSize,
229                         FullMemberName, symbols, ErrMsg);
230
231     // If the bitcode parsed successfully
232     if ( MP ) {
233       for (std::vector<std::string>::iterator SI = symbols.begin(),
234            SE = symbols.end(); SI != SE; ++SI) {
235
236         std::pair<SymTabType::iterator,bool> Res =
237           symTab.insert(std::make_pair(*SI,filepos));
238
239         if (Res.second) {
240           symTabSize += SI->length() +
241                         numVbrBytes(SI->length()) +
242                         numVbrBytes(filepos);
243         }
244       }
245       // We don't need this module any more.
246       delete MP;
247     } else {
248       if (mFile != 0) {
249         mFile->close();
250         delete mFile;
251       }
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   if (mFile != 0) {
283     mFile->close();
284     delete mFile;
285   }
286   return false;
287 }
288
289 // Write out the LLVM symbol table as an archive member to the file.
290 void
291 Archive::writeSymbolTable(std::ofstream& ARFile) {
292
293   // Construct the symbol table's header
294   ArchiveMemberHeader Hdr;
295   Hdr.init();
296   memcpy(Hdr.name,ARFILE_LLVM_SYMTAB_NAME,16);
297   uint64_t secondsSinceEpoch = sys::TimeValue::now().toEpochTime();
298   char buffer[32];
299   sprintf(buffer, "%-8o", 0644);
300   memcpy(Hdr.mode,buffer,8);
301   sprintf(buffer, "%-6u", sys::Process::GetCurrentUserId());
302   memcpy(Hdr.uid,buffer,6);
303   sprintf(buffer, "%-6u", sys::Process::GetCurrentGroupId());
304   memcpy(Hdr.gid,buffer,6);
305   sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch));
306   memcpy(Hdr.date,buffer,12);
307   sprintf(buffer,"%-10u",symTabSize);
308   memcpy(Hdr.size,buffer,10);
309
310   // Write the header
311   ARFile.write((char*)&Hdr, sizeof(Hdr));
312
313   // Save the starting position of the symbol tables data content.
314   unsigned startpos = ARFile.tellp();
315
316   // Write out the symbols sequentially
317   for ( Archive::SymTabType::iterator I = symTab.begin(), E = symTab.end();
318         I != E; ++I)
319   {
320     // Write out the file index
321     writeInteger(I->second, ARFile);
322     // Write out the length of the symbol
323     writeInteger(I->first.length(), ARFile);
324     // Write out the symbol
325     ARFile.write(I->first.data(), I->first.length());
326   }
327
328   // Now that we're done with the symbol table, get the ending file position
329   unsigned endpos = ARFile.tellp();
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.
344 bool
345 Archive::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->size() > 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
410     // Map in the archive we just wrote.
411     sys::MappedFile arch;
412     if (arch.open(TmpArchive, sys::MappedFile::READ_ACCESS, ErrMsg))
413       return true;
414     const char* base;
415     if (!(base = (const char*) arch.map(ErrMsg)))
416       return true;
417
418     // Open another temporary file in order to avoid invalidating the 
419     // mmapped data
420     sys::Path FinalFilePath = archPath;
421     if (FinalFilePath.createTemporaryFileOnDisk(ErrMsg))
422       return true;
423     sys::RemoveFileOnSignal(FinalFilePath);
424
425     std::ofstream FinalFile(FinalFilePath.c_str(), io_mode);
426     if (!FinalFile.is_open() || FinalFile.bad()) {
427       if (TmpArchive.exists())
428         TmpArchive.eraseFromDisk();
429       if (ErrMsg)
430         *ErrMsg = "Error opening archive file: " + FinalFilePath.toString();
431       return true;
432     }
433
434     // Write the file magic number
435     FinalFile << ARFILE_MAGIC;
436
437     // If there is a foreign symbol table, put it into the file now. Most
438     // ar(1) implementations require the symbol table to be first but llvm-ar
439     // can deal with it being after a foreign symbol table. This ensures
440     // compatibility with other ar(1) implementations as well as allowing the
441     // archive to store both native .o and LLVM .bc files, both indexed.
442     if (foreignST) {
443       if (writeMember(*foreignST, FinalFile, false, false, false, ErrMsg)) {
444         FinalFile.close();
445         if (TmpArchive.exists())
446           TmpArchive.eraseFromDisk();
447         return true;
448       }
449     }
450
451     // Put out the LLVM symbol table now.
452     writeSymbolTable(FinalFile);
453
454     // Copy the temporary file contents being sure to skip the file's magic
455     // number.
456     FinalFile.write(base + sizeof(ARFILE_MAGIC)-1,
457       arch.size()-sizeof(ARFILE_MAGIC)+1);
458
459     // Close up shop
460     FinalFile.close();
461     arch.close();
462     
463     // Move the final file over top of TmpArchive
464     if (FinalFilePath.renamePathOnDisk(TmpArchive, ErrMsg))
465       return true;
466   }
467   
468   // Before we replace the actual archive, we need to forget all the
469   // members, since they point to data in that old archive. We need to do
470   // this because we cannot replace an open file on Windows.
471   cleanUpMemory();
472   
473   if (TmpArchive.renamePathOnDisk(archPath, ErrMsg))
474     return true;
475
476   return false;
477 }