Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 1 | //===-- Archive.cpp - Generic LLVM archive functions ------------*- C++ -*-===// |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 2 | // |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame^] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 7 | // |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 10 | // This file contains the implementation of the Archive and ArchiveMember |
| 11 | // classes that is common to both reading and writing archives.. |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "ArchiveInternals.h" |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 16 | #include "llvm/Bitcode/ReaderWriter.h" |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 17 | #include "llvm/ModuleProvider.h" |
Chris Lattner | f36c7b8 | 2007-02-07 23:53:17 +0000 | [diff] [blame] | 18 | #include "llvm/Module.h" |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 19 | #include "llvm/Support/MemoryBuffer.h" |
Reid Spencer | 8e827e8 | 2005-04-21 17:49:57 +0000 | [diff] [blame] | 20 | #include "llvm/System/Process.h" |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 21 | using namespace llvm; |
| 22 | |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 23 | // getMemberSize - compute the actual physical size of the file member as seen |
| 24 | // on disk. This isn't the size of member's payload. Use getSize() for that. |
| 25 | unsigned |
| 26 | ArchiveMember::getMemberSize() const { |
| 27 | // Basically its the file size plus the header size |
| 28 | unsigned result = info.fileSize + sizeof(ArchiveMemberHeader); |
| 29 | |
| 30 | // If it has a long filename, include the name length |
| 31 | if (hasLongFilename()) |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 32 | result += path.toString().length() + 1; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 33 | |
| 34 | // If its now odd lengthed, include the padding byte |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 35 | if (result % 2 != 0 ) |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 36 | result++; |
| 37 | |
| 38 | return result; |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 39 | } |
| 40 | |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 41 | // This default constructor is only use by the ilist when it creates its |
| 42 | // sentry node. We give it specific static values to make it stand out a bit. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 43 | ArchiveMember::ArchiveMember() |
Jeff Cohen | 943b9b6 | 2006-05-06 23:25:53 +0000 | [diff] [blame] | 44 | : next(0), prev(0), parent(0), path("--invalid--"), flags(0), data(0) |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 45 | { |
Reid Spencer | 8e827e8 | 2005-04-21 17:49:57 +0000 | [diff] [blame] | 46 | info.user = sys::Process::GetCurrentUserId(); |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 47 | info.group = sys::Process::GetCurrentGroupId(); |
| 48 | info.mode = 0777; |
| 49 | info.fileSize = 0; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 50 | info.modTime = sys::TimeValue::now(); |
| 51 | } |
| 52 | |
| 53 | // This is the constructor that the Archive class uses when it is building or |
| 54 | // reading an archive. It just defaults a few things and ensures the parent is |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 55 | // set for the iplist. The Archive class fills in the ArchiveMember's data. |
| 56 | // This is required because correctly setting the data may depend on other |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 57 | // things in the Archive. |
| 58 | ArchiveMember::ArchiveMember(Archive* PAR) |
| 59 | : next(0), prev(0), parent(PAR), path(), flags(0), data(0) |
| 60 | { |
| 61 | } |
| 62 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 63 | // This method allows an ArchiveMember to be replaced with the data for a |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 64 | // different file, presumably as an update to the member. It also makes sure |
| 65 | // the flags are reset correctly. |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 66 | bool ArchiveMember::replaceWith(const sys::Path& newFile, std::string* ErrMsg) { |
Reid Spencer | cd5561a | 2006-12-15 19:44:51 +0000 | [diff] [blame] | 67 | if (!newFile.exists()) { |
| 68 | if (ErrMsg) |
| 69 | *ErrMsg = "Can not replace an archive member with a non-existent file"; |
| 70 | return true; |
| 71 | } |
| 72 | |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 73 | data = 0; |
| 74 | path = newFile; |
| 75 | |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 76 | // SVR4 symbol tables have an empty name |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 77 | if (path.toString() == ARFILE_SVR4_SYMTAB_NAME) |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 78 | flags |= SVR4SymbolTableFlag; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 79 | else |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 80 | flags &= ~SVR4SymbolTableFlag; |
| 81 | |
| 82 | // BSD4.4 symbol tables have a special name |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 83 | if (path.toString() == ARFILE_BSD4_SYMTAB_NAME) |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 84 | flags |= BSD4SymbolTableFlag; |
| 85 | else |
| 86 | flags &= ~BSD4SymbolTableFlag; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 87 | |
| 88 | // LLVM symbol tables have a very specific name |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 89 | if (path.toString() == ARFILE_LLVM_SYMTAB_NAME) |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 90 | flags |= LLVMSymbolTableFlag; |
| 91 | else |
| 92 | flags &= ~LLVMSymbolTableFlag; |
| 93 | |
| 94 | // String table name |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 95 | if (path.toString() == ARFILE_STRTAB_NAME) |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 96 | flags |= StringTableFlag; |
| 97 | else |
| 98 | flags &= ~StringTableFlag; |
| 99 | |
| 100 | // If it has a slash then it has a path |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 101 | bool hasSlash = path.toString().find('/') != std::string::npos; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 102 | if (hasSlash) |
| 103 | flags |= HasPathFlag; |
| 104 | else |
| 105 | flags &= ~HasPathFlag; |
| 106 | |
| 107 | // If it has a slash or its over 15 chars then its a long filename format |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 108 | if (hasSlash || path.toString().length() > 15) |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 109 | flags |= HasLongFilenameFlag; |
| 110 | else |
| 111 | flags &= ~HasLongFilenameFlag; |
| 112 | |
| 113 | // Get the signature and status info |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 114 | const char* signature = (const char*) data; |
Chris Lattner | 252ad03 | 2006-07-28 22:03:44 +0000 | [diff] [blame] | 115 | std::string magic; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 116 | if (!signature) { |
| 117 | path.getMagicNumber(magic,4); |
| 118 | signature = magic.c_str(); |
Chris Lattner | 252ad03 | 2006-07-28 22:03:44 +0000 | [diff] [blame] | 119 | std::string err; |
Reid Spencer | a021d5d | 2007-04-07 19:51:45 +0000 | [diff] [blame] | 120 | const sys::FileStatus *FSinfo = path.getFileStatus(false, ErrMsg); |
Reid Spencer | 8475ec0 | 2007-03-29 19:05:44 +0000 | [diff] [blame] | 121 | if (FSinfo) |
| 122 | info = *FSinfo; |
| 123 | else |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 124 | return true; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | // Determine what kind of file it is |
| 128 | switch (sys::IdentifyFileType(signature,4)) { |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 129 | default: |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 130 | flags &= ~BitcodeFlag; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 131 | break; |
| 132 | } |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 133 | return false; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | // Archive constructor - this is the only constructor that gets used for the |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 137 | // Archive class. Everything else (default,copy) is deprecated. This just |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 138 | // initializes and maps the file into memory, if requested. |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 139 | Archive::Archive(const sys::Path& filename) |
Reid Spencer | 1f46580 | 2004-11-16 06:47:07 +0000 | [diff] [blame] | 140 | : archPath(filename), members(), mapfile(0), base(0), symTab(), strtab(), |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 141 | symTabSize(0), firstFileOffset(0), modules(), foreignST(0) { |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | bool |
| 145 | Archive::mapToMemory(std::string* ErrMsg) |
| 146 | { |
| 147 | mapfile = new sys::MappedFile(); |
| 148 | if (mapfile->open(archPath, sys::MappedFile::READ_ACCESS, ErrMsg)) |
| 149 | return true; |
| 150 | if (!(base = (char*) mapfile->map(ErrMsg))) |
| 151 | return true; |
| 152 | return false; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 153 | } |
| 154 | |
Reid Spencer | 6ff7240 | 2005-11-30 05:21:10 +0000 | [diff] [blame] | 155 | void Archive::cleanUpMemory() { |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 156 | // Shutdown the file mapping |
| 157 | if (mapfile) { |
Jeff Cohen | d19d89a | 2005-01-28 01:17:07 +0000 | [diff] [blame] | 158 | mapfile->close(); |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 159 | delete mapfile; |
Reid Spencer | 6ff7240 | 2005-11-30 05:21:10 +0000 | [diff] [blame] | 160 | |
| 161 | mapfile = 0; |
| 162 | base = 0; |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 163 | } |
Reid Spencer | 6ff7240 | 2005-11-30 05:21:10 +0000 | [diff] [blame] | 164 | |
| 165 | // Forget the entire symbol table |
| 166 | symTab.clear(); |
| 167 | symTabSize = 0; |
| 168 | |
| 169 | firstFileOffset = 0; |
| 170 | |
| 171 | // Free the foreign symbol table member |
| 172 | if (foreignST) { |
| 173 | delete foreignST; |
| 174 | foreignST = 0; |
| 175 | } |
| 176 | |
Reid Spencer | cf6afc6 | 2004-11-14 21:56:59 +0000 | [diff] [blame] | 177 | // Delete any ModuleProviders and ArchiveMember's we've allocated as a result |
| 178 | // of symbol table searches. |
| 179 | for (ModuleMap::iterator I=modules.begin(), E=modules.end(); I != E; ++I ) { |
| 180 | delete I->second.first; |
| 181 | delete I->second.second; |
| 182 | } |
Reid Spencer | 362cbf0 | 2004-11-06 08:51:45 +0000 | [diff] [blame] | 183 | } |
| 184 | |
Reid Spencer | 6ff7240 | 2005-11-30 05:21:10 +0000 | [diff] [blame] | 185 | // Archive destructor - just clean up memory |
| 186 | Archive::~Archive() { |
| 187 | cleanUpMemory(); |
| 188 | } |
| 189 | |
Chris Lattner | f36c7b8 | 2007-02-07 23:53:17 +0000 | [diff] [blame] | 190 | |
| 191 | |
| 192 | static void getSymbols(Module*M, std::vector<std::string>& symbols) { |
| 193 | // Loop over global variables |
| 194 | for (Module::global_iterator GI = M->global_begin(), GE=M->global_end(); GI != GE; ++GI) |
| 195 | if (!GI->isDeclaration() && !GI->hasInternalLinkage()) |
| 196 | if (!GI->getName().empty()) |
| 197 | symbols.push_back(GI->getName()); |
| 198 | |
| 199 | // Loop over functions. |
| 200 | for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) |
| 201 | if (!FI->isDeclaration() && !FI->hasInternalLinkage()) |
| 202 | if (!FI->getName().empty()) |
| 203 | symbols.push_back(FI->getName()); |
| 204 | } |
| 205 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 206 | // Get just the externally visible defined symbols from the bitcode |
| 207 | bool llvm::GetBitcodeSymbols(const sys::Path& fName, |
| 208 | std::vector<std::string>& symbols, |
| 209 | std::string* ErrMsg) { |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 210 | std::auto_ptr<MemoryBuffer> Buffer( |
| 211 | MemoryBuffer::getFileOrSTDIN(&fName.toString()[0], |
| 212 | fName.toString().size())); |
| 213 | if (!Buffer.get()) { |
| 214 | if (ErrMsg) *ErrMsg = "Could not open file '" + fName.toString() + "'"; |
| 215 | return true; |
| 216 | } |
| 217 | |
| 218 | ModuleProvider *MP = getBitcodeModuleProvider(Buffer.get(), ErrMsg); |
Chris Lattner | f36c7b8 | 2007-02-07 23:53:17 +0000 | [diff] [blame] | 219 | if (!MP) |
| 220 | return true; |
| 221 | |
| 222 | // Get the module from the provider |
| 223 | Module* M = MP->materializeModule(); |
| 224 | if (M == 0) { |
| 225 | delete MP; |
| 226 | return true; |
| 227 | } |
| 228 | |
| 229 | // Get the symbols |
| 230 | getSymbols(M, symbols); |
| 231 | |
| 232 | // Done with the module. |
| 233 | delete MP; |
| 234 | return true; |
| 235 | } |
| 236 | |
| 237 | ModuleProvider* |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 238 | llvm::GetBitcodeSymbols(const unsigned char *BufPtr, unsigned Length, |
| 239 | const std::string& ModuleID, |
| 240 | std::vector<std::string>& symbols, |
| 241 | std::string* ErrMsg) { |
Chris Lattner | f36c7b8 | 2007-02-07 23:53:17 +0000 | [diff] [blame] | 242 | // Get the module provider |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 243 | MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(Length, ModuleID.c_str()); |
| 244 | memcpy((char*)Buffer->getBufferStart(), BufPtr, Length); |
| 245 | |
| 246 | ModuleProvider *MP = getBitcodeModuleProvider(Buffer, ErrMsg); |
Chris Lattner | f36c7b8 | 2007-02-07 23:53:17 +0000 | [diff] [blame] | 247 | if (!MP) |
| 248 | return 0; |
| 249 | |
| 250 | // Get the module from the provider |
| 251 | Module* M = MP->materializeModule(); |
| 252 | if (M == 0) { |
| 253 | delete MP; |
| 254 | return 0; |
| 255 | } |
| 256 | |
| 257 | // Get the symbols |
| 258 | getSymbols(M, symbols); |
| 259 | |
| 260 | // Done with the module. Note that ModuleProvider will delete the |
| 261 | // Module when it is deleted. Also note that its the caller's responsibility |
| 262 | // to delete the ModuleProvider. |
| 263 | return MP; |
| 264 | } |