Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 1 | //===-- ArchiveReader.cpp - Read LLVM archive files -------------*- C++ -*-===// |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +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 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 9 | // |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 10 | // Builds up standard unix archive files (.a) containing LLVM bitcode. |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 14 | #include "ArchiveInternals.h" |
Chris Lattner | e07c15c | 2007-05-06 06:18:07 +0000 | [diff] [blame] | 15 | #include "llvm/Bitcode/ReaderWriter.h" |
Chris Lattner | e07c15c | 2007-05-06 06:18:07 +0000 | [diff] [blame] | 16 | #include "llvm/Support/MemoryBuffer.h" |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 17 | #include "llvm/Module.h" |
Duraid Madina | 8748746 | 2005-12-26 14:31:26 +0000 | [diff] [blame] | 18 | #include <memory> |
Chris Lattner | 3446ae8 | 2004-01-10 19:00:15 +0000 | [diff] [blame] | 19 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 20 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 21 | /// Read a variable-bit-rate encoded unsigned integer |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 22 | inline unsigned readInteger(const char*&At, const char*End){ |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 23 | unsigned Shift = 0; |
| 24 | unsigned Result = 0; |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 25 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 26 | do { |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 27 | if (At == End) |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 28 | return Result; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 29 | Result |= (unsigned)((*At++) & 0x7F) << Shift; |
| 30 | Shift += 7; |
| 31 | } while (At[-1] & 0x80); |
| 32 | return Result; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 33 | } |
| 34 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 35 | // Completely parse the Archive's symbol table and populate symTab member var. |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 36 | bool |
| 37 | Archive::parseSymbolTable(const void* data, unsigned size, std::string* error) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 38 | const char* At = (const char*) data; |
| 39 | const char* End = At + size; |
| 40 | while (At < End) { |
| 41 | unsigned offset = readInteger(At, End); |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 42 | if (At == End) { |
| 43 | if (error) |
| 44 | *error = "Ran out of data reading vbr_uint for symtab offset!"; |
| 45 | return false; |
| 46 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 47 | unsigned length = readInteger(At, End); |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 48 | if (At == End) { |
| 49 | if (error) |
| 50 | *error = "Ran out of data reading vbr_uint for symtab length!"; |
| 51 | return false; |
| 52 | } |
| 53 | if (At + length > End) { |
| 54 | if (error) |
| 55 | *error = "Malformed symbol table: length not consistent with size"; |
| 56 | return false; |
| 57 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 58 | // we don't care if it can't be inserted (duplicate entry) |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 59 | symTab.insert(std::make_pair(std::string(At, length), offset)); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 60 | At += length; |
| 61 | } |
| 62 | symTabSize = size; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 63 | return true; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 64 | } |
| 65 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 66 | // This member parses an ArchiveMemberHeader that is presumed to be pointed to |
| 67 | // by At. The At pointer is updated to the byte just after the header, which |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 68 | // can be variable in size. |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 69 | ArchiveMember* |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 70 | Archive::parseMemberHeader(const char*& At, const char* End, std::string* error) |
| 71 | { |
Reid Spencer | cd5561a | 2006-12-15 19:44:51 +0000 | [diff] [blame] | 72 | if (At + sizeof(ArchiveMemberHeader) >= End) { |
| 73 | if (error) |
| 74 | *error = "Unexpected end of file"; |
| 75 | return 0; |
| 76 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 77 | |
| 78 | // Cast archive member header |
| 79 | ArchiveMemberHeader* Hdr = (ArchiveMemberHeader*)At; |
| 80 | At += sizeof(ArchiveMemberHeader); |
| 81 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 82 | // Extract the size and determine if the file is |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 83 | // compressed or not (negative length). |
| 84 | int flags = 0; |
| 85 | int MemberSize = atoi(Hdr->size); |
| 86 | if (MemberSize < 0) { |
| 87 | flags |= ArchiveMember::CompressedFlag; |
| 88 | MemberSize = -MemberSize; |
| 89 | } |
| 90 | |
| 91 | // Check the size of the member for sanity |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 92 | if (At + MemberSize > End) { |
| 93 | if (error) |
| 94 | *error = "invalid member length in archive file"; |
| 95 | return 0; |
| 96 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 97 | |
| 98 | // Check the member signature |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 99 | if (!Hdr->checkSignature()) { |
| 100 | if (error) |
| 101 | *error = "invalid file member signature"; |
| 102 | return 0; |
| 103 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 104 | |
| 105 | // Convert and check the member name |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 106 | // The empty name ( '/' and 15 blanks) is for a foreign (non-LLVM) symbol |
| 107 | // table. The special name "//" and 14 blanks is for a string table, used |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 108 | // for long file names. This library doesn't generate either of those but |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 109 | // it will accept them. If the name starts with #1/ and the remainder is |
| 110 | // digits, then those digits specify the length of the name that is |
| 111 | // stored immediately following the header. The special name |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 112 | // __LLVM_SYM_TAB__ identifies the symbol table for LLVM bitcode. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 113 | // Anything else is a regular, short filename that is terminated with |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 114 | // a '/' and blanks. |
| 115 | |
| 116 | std::string pathname; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 117 | switch (Hdr->name[0]) { |
| 118 | case '#': |
| 119 | if (Hdr->name[1] == '1' && Hdr->name[2] == '/') { |
| 120 | if (isdigit(Hdr->name[3])) { |
| 121 | unsigned len = atoi(&Hdr->name[3]); |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 122 | pathname.assign(At, len); |
Reid Spencer | dd95e8d | 2004-11-17 16:13:11 +0000 | [diff] [blame] | 123 | At += len; |
| 124 | MemberSize -= len; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 125 | flags |= ArchiveMember::HasLongFilenameFlag; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 126 | } else { |
| 127 | if (error) |
| 128 | *error = "invalid long filename"; |
| 129 | return 0; |
| 130 | } |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 131 | } else if (Hdr->name[1] == '_' && |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 132 | (0 == memcmp(Hdr->name, ARFILE_LLVM_SYMTAB_NAME, 16))) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 133 | // The member is using a long file name (>15 chars) format. |
| 134 | // This format is standard for 4.4BSD and Mac OSX operating |
| 135 | // systems. LLVM uses it similarly. In this format, the |
| 136 | // remainder of the name field (after #1/) specifies the |
| 137 | // length of the file name which occupy the first bytes of |
| 138 | // the member's data. The pathname already has the #1/ stripped. |
| 139 | pathname.assign(ARFILE_LLVM_SYMTAB_NAME); |
| 140 | flags |= ArchiveMember::LLVMSymbolTableFlag; |
| 141 | } |
| 142 | break; |
| 143 | case '/': |
| 144 | if (Hdr->name[1]== '/') { |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 145 | if (0 == memcmp(Hdr->name, ARFILE_STRTAB_NAME, 16)) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 146 | pathname.assign(ARFILE_STRTAB_NAME); |
| 147 | flags |= ArchiveMember::StringTableFlag; |
| 148 | } else { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 149 | if (error) |
| 150 | *error = "invalid string table name"; |
| 151 | return 0; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 152 | } |
| 153 | } else if (Hdr->name[1] == ' ') { |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 154 | if (0 == memcmp(Hdr->name, ARFILE_SVR4_SYMTAB_NAME, 16)) { |
| 155 | pathname.assign(ARFILE_SVR4_SYMTAB_NAME); |
| 156 | flags |= ArchiveMember::SVR4SymbolTableFlag; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 157 | } else { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 158 | if (error) |
| 159 | *error = "invalid SVR4 symbol table name"; |
| 160 | return 0; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 161 | } |
| 162 | } else if (isdigit(Hdr->name[1])) { |
| 163 | unsigned index = atoi(&Hdr->name[1]); |
| 164 | if (index < strtab.length()) { |
| 165 | const char* namep = strtab.c_str() + index; |
| 166 | const char* endp = strtab.c_str() + strtab.length(); |
| 167 | const char* p = namep; |
| 168 | const char* last_p = p; |
| 169 | while (p < endp) { |
| 170 | if (*p == '\n' && *last_p == '/') { |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 171 | pathname.assign(namep, last_p - namep); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 172 | flags |= ArchiveMember::HasLongFilenameFlag; |
| 173 | break; |
| 174 | } |
| 175 | last_p = p; |
| 176 | p++; |
| 177 | } |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 178 | if (p >= endp) { |
| 179 | if (error) |
| 180 | *error = "missing name termiantor in string table"; |
| 181 | return 0; |
| 182 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 183 | } else { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 184 | if (error) |
| 185 | *error = "name index beyond string table"; |
| 186 | return 0; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 187 | } |
| 188 | } |
| 189 | break; |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 190 | case '_': |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 191 | if (Hdr->name[1] == '_' && |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 192 | (0 == memcmp(Hdr->name, ARFILE_BSD4_SYMTAB_NAME, 16))) { |
| 193 | pathname.assign(ARFILE_BSD4_SYMTAB_NAME); |
| 194 | flags |= ArchiveMember::BSD4SymbolTableFlag; |
Reid Spencer | 84b9ced | 2004-11-23 22:35:39 +0000 | [diff] [blame] | 195 | break; |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 196 | } |
Reid Spencer | 84b9ced | 2004-11-23 22:35:39 +0000 | [diff] [blame] | 197 | /* FALL THROUGH */ |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 198 | |
| 199 | default: |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 200 | char* slash = (char*) memchr(Hdr->name, '/', 16); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 201 | if (slash == 0) |
Reid Spencer | dd95e8d | 2004-11-17 16:13:11 +0000 | [diff] [blame] | 202 | slash = Hdr->name + 16; |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 203 | pathname.assign(Hdr->name, slash - Hdr->name); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 204 | break; |
| 205 | } |
| 206 | |
Gabor Greif | db5565a | 2007-07-06 20:28:40 +0000 | [diff] [blame] | 207 | // Determine if this is a bitcode file |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 208 | switch (sys::IdentifyFileType(At, 4)) { |
Chris Lattner | e07c15c | 2007-05-06 06:18:07 +0000 | [diff] [blame] | 209 | case sys::Bitcode_FileType: |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 210 | flags |= ArchiveMember::BitcodeFlag; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 211 | break; |
| 212 | default: |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 213 | flags &= ~ArchiveMember::BitcodeFlag; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 214 | break; |
| 215 | } |
| 216 | |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 217 | // Instantiate the ArchiveMember to be filled |
| 218 | ArchiveMember* member = new ArchiveMember(this); |
| 219 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 220 | // Fill in fields of the ArchiveMember |
| 221 | member->next = 0; |
| 222 | member->prev = 0; |
| 223 | member->parent = this; |
Reid Spencer | dd04df0 | 2005-07-07 23:21:43 +0000 | [diff] [blame] | 224 | member->path.set(pathname); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 225 | member->info.fileSize = MemberSize; |
| 226 | member->info.modTime.fromEpochTime(atoi(Hdr->date)); |
Reid Spencer | 5612762 | 2004-12-29 01:20:24 +0000 | [diff] [blame] | 227 | unsigned int mode; |
| 228 | sscanf(Hdr->mode, "%o", &mode); |
| 229 | member->info.mode = mode; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 230 | member->info.user = atoi(Hdr->uid); |
| 231 | member->info.group = atoi(Hdr->gid); |
| 232 | member->flags = flags; |
| 233 | member->data = At; |
| 234 | |
| 235 | return member; |
| 236 | } |
| 237 | |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 238 | bool |
| 239 | Archive::checkSignature(std::string* error) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 240 | // Check the magic string at file's header |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 241 | if (mapfile->size() < 8 || memcmp(base, ARFILE_MAGIC, 8)) { |
| 242 | if (error) |
| 243 | *error = "invalid signature for an archive file"; |
| 244 | return false; |
| 245 | } |
| 246 | return true; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 247 | } |
| 248 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 249 | // This function loads the entire archive and fully populates its ilist with |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 250 | // the members of the archive file. This is typically used in preparation for |
| 251 | // editing the contents of the archive. |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 252 | bool |
| 253 | Archive::loadArchive(std::string* error) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 254 | |
| 255 | // Set up parsing |
| 256 | members.clear(); |
| 257 | symTab.clear(); |
| 258 | const char *At = base; |
| 259 | const char *End = base + mapfile->size(); |
| 260 | |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 261 | if (!checkSignature(error)) |
| 262 | return false; |
| 263 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 264 | At += 8; // Skip the magic string. |
| 265 | |
| 266 | bool seenSymbolTable = false; |
| 267 | bool foundFirstFile = false; |
| 268 | while (At < End) { |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 269 | // parse the member header |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 270 | const char* Save = At; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 271 | ArchiveMember* mbr = parseMemberHeader(At, End, error); |
| 272 | if (!mbr) |
| 273 | return false; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 274 | |
| 275 | // check if this is the foreign symbol table |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 276 | if (mbr->isSVR4SymbolTable() || mbr->isBSD4SymbolTable()) { |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 277 | // We just save this but don't do anything special |
| 278 | // with it. It doesn't count as the "first file". |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 279 | if (foreignST) { |
| 280 | // What? Multiple foreign symbol tables? Just chuck it |
| 281 | // and retain the last one found. |
| 282 | delete foreignST; |
| 283 | } |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 284 | foreignST = mbr; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 285 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 286 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 287 | At++; |
| 288 | } else if (mbr->isStringTable()) { |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 289 | // Simply suck the entire string table into a string |
| 290 | // variable. This will be used to get the names of the |
| 291 | // members that use the "/ddd" format for their names |
| 292 | // (SVR4 style long names). |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 293 | strtab.assign(At, mbr->getSize()); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 294 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 295 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 296 | At++; |
| 297 | delete mbr; |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 298 | } else if (mbr->isLLVMSymbolTable()) { |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 299 | // This is the LLVM symbol table for the archive. If we've seen it |
| 300 | // already, its an error. Otherwise, parse the symbol table and move on. |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 301 | if (seenSymbolTable) { |
| 302 | if (error) |
| 303 | *error = "invalid archive: multiple symbol tables"; |
| 304 | return false; |
| 305 | } |
| 306 | if (!parseSymbolTable(mbr->getData(), mbr->getSize(), error)) |
| 307 | return false; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 308 | seenSymbolTable = true; |
| 309 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 310 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 311 | At++; |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 312 | delete mbr; // We don't need this member in the list of members. |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 313 | } else { |
Reid Spencer | 4a980d1 | 2004-11-16 06:47:19 +0000 | [diff] [blame] | 314 | // This is just a regular file. If its the first one, save its offset. |
| 315 | // Otherwise just push it on the list and move on to the next file. |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 316 | if (!foundFirstFile) { |
| 317 | firstFileOffset = Save - base; |
| 318 | foundFirstFile = true; |
| 319 | } |
| 320 | members.push_back(mbr); |
| 321 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 322 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 323 | At++; |
| 324 | } |
| 325 | } |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 326 | return true; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 327 | } |
| 328 | |
| 329 | // Open and completely load the archive file. |
| 330 | Archive* |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 331 | Archive::OpenAndLoad(const sys::Path& file, std::string* ErrorMessage) |
| 332 | { |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 333 | std::auto_ptr<Archive> result ( new Archive(file)); |
| 334 | if (result->mapToMemory(ErrorMessage)) |
| 335 | return 0; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 336 | if (!result->loadArchive(ErrorMessage)) |
Reid Spencer | 5af4688 | 2004-12-13 02:59:03 +0000 | [diff] [blame] | 337 | return 0; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 338 | return result.release(); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 339 | } |
| 340 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 341 | // Get all the bitcode modules from the archive |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 342 | bool |
| 343 | Archive::getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage) { |
| 344 | |
| 345 | for (iterator I=begin(), E=end(); I != E; ++I) { |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 346 | if (I->isBitcode()) { |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 347 | std::string FullMemberName = archPath.toString() + |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 348 | "(" + I->getPath().toString() + ")"; |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 349 | MemoryBuffer *Buffer = |
| 350 | MemoryBuffer::getNewMemBuffer(I->getSize(), FullMemberName.c_str()); |
| 351 | memcpy((char*)Buffer->getBufferStart(), I->getData(), I->getSize()); |
Chris Lattner | e07c15c | 2007-05-06 06:18:07 +0000 | [diff] [blame] | 352 | |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 353 | Module *M = ParseBitcodeFile(Buffer, ErrMessage); |
| 354 | delete Buffer; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 355 | if (!M) |
| 356 | return true; |
| 357 | |
| 358 | Modules.push_back(M); |
| 359 | } |
| 360 | } |
Brian Gaeke | 2c61d7b | 2003-11-16 23:08:48 +0000 | [diff] [blame] | 361 | return false; |
| 362 | } |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 363 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 364 | // Load just the symbol table from the archive file |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 365 | bool |
| 366 | Archive::loadSymbolTable(std::string* ErrorMsg) { |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 367 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 368 | // Set up parsing |
| 369 | members.clear(); |
| 370 | symTab.clear(); |
| 371 | const char *At = base; |
| 372 | const char *End = base + mapfile->size(); |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 373 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 374 | // Make sure we're dealing with an archive |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 375 | if (!checkSignature(ErrorMsg)) |
| 376 | return false; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 377 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 378 | At += 8; // Skip signature |
| 379 | |
| 380 | // Parse the first file member header |
| 381 | const char* FirstFile = At; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 382 | ArchiveMember* mbr = parseMemberHeader(At, End, ErrorMsg); |
| 383 | if (!mbr) |
| 384 | return false; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 385 | |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 386 | if (mbr->isSVR4SymbolTable() || mbr->isBSD4SymbolTable()) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 387 | // Skip the foreign symbol table, we don't do anything with it |
| 388 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 389 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 390 | At++; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 391 | delete mbr; |
| 392 | |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 393 | // Read the next one |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 394 | FirstFile = At; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 395 | mbr = parseMemberHeader(At, End, ErrorMsg); |
| 396 | if (!mbr) { |
| 397 | delete mbr; |
| 398 | return false; |
| 399 | } |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 400 | } |
| 401 | |
| 402 | if (mbr->isStringTable()) { |
| 403 | // Process the string table entry |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 404 | strtab.assign((const char*)mbr->getData(), mbr->getSize()); |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 405 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 406 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 407 | At++; |
| 408 | delete mbr; |
| 409 | // Get the next one |
| 410 | FirstFile = At; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 411 | mbr = parseMemberHeader(At, End, ErrorMsg); |
| 412 | if (!mbr) { |
| 413 | delete mbr; |
| 414 | return false; |
| 415 | } |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 416 | } |
| 417 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 418 | // See if its the symbol table |
| 419 | if (mbr->isLLVMSymbolTable()) { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 420 | if (!parseSymbolTable(mbr->getData(), mbr->getSize(), ErrorMsg)) { |
| 421 | delete mbr; |
| 422 | return false; |
| 423 | } |
| 424 | |
Reid Spencer | 8dde18f | 2004-11-28 03:13:02 +0000 | [diff] [blame] | 425 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 426 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | 8dde18f | 2004-11-28 03:13:02 +0000 | [diff] [blame] | 427 | At++; |
Reid Spencer | ffb4d62 | 2006-05-12 17:56:20 +0000 | [diff] [blame] | 428 | delete mbr; |
| 429 | // Can't be any more symtab headers so just advance |
Reid Spencer | 8dde18f | 2004-11-28 03:13:02 +0000 | [diff] [blame] | 430 | FirstFile = At; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 431 | } else { |
| 432 | // There's no symbol table in the file. We have to rebuild it from scratch |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 433 | // because the intent of this method is to get the symbol table loaded so |
| 434 | // it can be searched efficiently. |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 435 | // Add the member to the members list |
| 436 | members.push_back(mbr); |
| 437 | } |
| 438 | |
| 439 | firstFileOffset = FirstFile - base; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 440 | return true; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 441 | } |
| 442 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 443 | // Open the archive and load just the symbol tables |
| 444 | Archive* |
Reid Spencer | 5af4688 | 2004-12-13 02:59:03 +0000 | [diff] [blame] | 445 | Archive::OpenAndLoadSymbols(const sys::Path& file, std::string* ErrorMessage) { |
Reid Spencer | 0ff2d31 | 2006-08-24 23:45:08 +0000 | [diff] [blame] | 446 | std::auto_ptr<Archive> result ( new Archive(file) ); |
| 447 | if (result->mapToMemory(ErrorMessage)) |
| 448 | return 0; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 449 | if (!result->loadSymbolTable(ErrorMessage)) |
Reid Spencer | 5af4688 | 2004-12-13 02:59:03 +0000 | [diff] [blame] | 450 | return 0; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 451 | return result.release(); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 452 | } |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 453 | |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 454 | // Look up one symbol in the symbol table and return a ModuleProvider for the |
| 455 | // module that defines that symbol. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 456 | ModuleProvider* |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 457 | Archive::findModuleDefiningSymbol(const std::string& symbol, |
| 458 | std::string* ErrMsg) { |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 459 | SymTabType::iterator SI = symTab.find(symbol); |
| 460 | if (SI == symTab.end()) |
| 461 | return 0; |
| 462 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 463 | // The symbol table was previously constructed assuming that the members were |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 464 | // written without the symbol table header. Because VBR encoding is used, the |
| 465 | // values could not be adjusted to account for the offset of the symbol table |
| 466 | // because that could affect the size of the symbol table due to VBR encoding. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 467 | // We now have to account for this by adjusting the offset by the size of the |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 468 | // symbol table and its header. |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 469 | unsigned fileOffset = |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 470 | SI->second + // offset in symbol-table-less file |
| 471 | firstFileOffset; // add offset to first "real" file in archive |
| 472 | |
| 473 | // See if the module is already loaded |
| 474 | ModuleMap::iterator MI = modules.find(fileOffset); |
| 475 | if (MI != modules.end()) |
| 476 | return MI->second.first; |
| 477 | |
| 478 | // Module hasn't been loaded yet, we need to load it |
| 479 | const char* modptr = base + fileOffset; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 480 | ArchiveMember* mbr = parseMemberHeader(modptr, base + mapfile->size(),ErrMsg); |
| 481 | if (!mbr) |
Reid Spencer | 0b5a504 | 2006-08-25 17:43:11 +0000 | [diff] [blame] | 482 | return 0; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 483 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 484 | // Now, load the bitcode module to get the ModuleProvider |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 485 | std::string FullMemberName = archPath.toString() + "(" + |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 486 | mbr->getPath().toString() + ")"; |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 487 | MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(mbr->getSize(), |
| 488 | FullMemberName.c_str()); |
| 489 | memcpy((char*)Buffer->getBufferStart(), mbr->getData(), mbr->getSize()); |
| 490 | |
| 491 | ModuleProvider *mp = getBitcodeModuleProvider(Buffer, ErrMsg); |
Reid Spencer | 0b5a504 | 2006-08-25 17:43:11 +0000 | [diff] [blame] | 492 | if (!mp) |
| 493 | return 0; |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 494 | |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 495 | modules.insert(std::make_pair(fileOffset, std::make_pair(mp, mbr))); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 496 | |
| 497 | return mp; |
| 498 | } |
| 499 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 500 | // Look up multiple symbols in the symbol table and return a set of |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 501 | // ModuleProviders that define those symbols. |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 502 | bool |
Reid Spencer | 7783e8a | 2004-11-19 03:18:22 +0000 | [diff] [blame] | 503 | Archive::findModulesDefiningSymbols(std::set<std::string>& symbols, |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 504 | std::set<ModuleProvider*>& result, |
Chris Lattner | f2e292c | 2007-02-07 21:41:02 +0000 | [diff] [blame] | 505 | std::string* error) { |
Reid Spencer | cd5561a | 2006-12-15 19:44:51 +0000 | [diff] [blame] | 506 | if (!mapfile || !base) { |
| 507 | if (error) |
| 508 | *error = "Empty archive invalid for finding modules defining symbols"; |
| 509 | return false; |
| 510 | } |
| 511 | |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 512 | if (symTab.empty()) { |
| 513 | // We don't have a symbol table, so we must build it now but lets also |
| 514 | // make sure that we populate the modules table as we do this to ensure |
| 515 | // that we don't load them twice when findModuleDefiningSymbol is called |
| 516 | // below. |
| 517 | |
| 518 | // Get a pointer to the first file |
| 519 | const char* At = ((const char*)base) + firstFileOffset; |
| 520 | const char* End = ((const char*)base) + mapfile->size(); |
| 521 | |
| 522 | while ( At < End) { |
| 523 | // Compute the offset to be put in the symbol table |
| 524 | unsigned offset = At - base - firstFileOffset; |
| 525 | |
| 526 | // Parse the file's header |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 527 | ArchiveMember* mbr = parseMemberHeader(At, End, error); |
| 528 | if (!mbr) |
| 529 | return false; |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 530 | |
| 531 | // If it contains symbols |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 532 | if (mbr->isBitcode()) { |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 533 | // Get the symbols |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 534 | std::vector<std::string> symbols; |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 535 | std::string FullMemberName = archPath.toString() + "(" + |
Reid Spencer | 1fce091 | 2004-12-11 00:14:15 +0000 | [diff] [blame] | 536 | mbr->getPath().toString() + ")"; |
Chris Lattner | f2e292c | 2007-02-07 21:41:02 +0000 | [diff] [blame] | 537 | ModuleProvider* MP = |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 538 | GetBitcodeSymbols((const unsigned char*)At, mbr->getSize(), |
| 539 | FullMemberName, symbols, error); |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 540 | |
| 541 | if (MP) { |
| 542 | // Insert the module's symbols into the symbol table |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 543 | for (std::vector<std::string>::iterator I = symbols.begin(), |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 544 | E=symbols.end(); I != E; ++I ) { |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 545 | symTab.insert(std::make_pair(*I, offset)); |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 546 | } |
| 547 | // Insert the ModuleProvider and the ArchiveMember into the table of |
| 548 | // modules. |
Reid Spencer | 9a29db4 | 2004-11-20 07:29:40 +0000 | [diff] [blame] | 549 | modules.insert(std::make_pair(offset, std::make_pair(MP, mbr))); |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 550 | } else { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 551 | if (error) |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 552 | *error = "Can't parse bitcode member: " + |
Reid Spencer | 0b5a504 | 2006-08-25 17:43:11 +0000 | [diff] [blame] | 553 | mbr->getPath().toString() + ": " + *error; |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 554 | delete mbr; |
| 555 | return false; |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 556 | } |
| 557 | } |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 558 | |
| 559 | // Go to the next file location |
| 560 | At += mbr->getSize(); |
Reid Spencer | 6405c9e | 2004-11-19 17:08:00 +0000 | [diff] [blame] | 561 | if ((intptr_t(At) & 1) == 1) |
Reid Spencer | b323113 | 2004-11-15 01:40:20 +0000 | [diff] [blame] | 562 | At++; |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 563 | } |
| 564 | } |
| 565 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 566 | // At this point we have a valid symbol table (one way or another) so we |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 567 | // just use it to quickly find the symbols requested. |
| 568 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 569 | for (std::set<std::string>::iterator I=symbols.begin(), |
Reid Spencer | 7783e8a | 2004-11-19 03:18:22 +0000 | [diff] [blame] | 570 | E=symbols.end(); I != E;) { |
| 571 | // See if this symbol exists |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 572 | ModuleProvider* mp = findModuleDefiningSymbol(*I,error); |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 573 | if (mp) { |
Reid Spencer | 7783e8a | 2004-11-19 03:18:22 +0000 | [diff] [blame] | 574 | // The symbol exists, insert the ModuleProvider into our result, |
| 575 | // duplicates wil be ignored |
Reid Spencer | 766b793 | 2004-11-15 01:20:11 +0000 | [diff] [blame] | 576 | result.insert(mp); |
Reid Spencer | 7783e8a | 2004-11-19 03:18:22 +0000 | [diff] [blame] | 577 | |
Misha Brukman | 2b37d7c | 2005-04-21 21:13:18 +0000 | [diff] [blame] | 578 | // Remove the symbol now that its been resolved, being careful to |
Reid Spencer | 57646ec | 2004-11-19 03:44:10 +0000 | [diff] [blame] | 579 | // post-increment the iterator. |
| 580 | symbols.erase(I++); |
Reid Spencer | 7783e8a | 2004-11-19 03:18:22 +0000 | [diff] [blame] | 581 | } else { |
| 582 | ++I; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 583 | } |
Reid Spencer | f9d7a51 | 2004-11-14 21:58:33 +0000 | [diff] [blame] | 584 | } |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 585 | return true; |
Chris Lattner | 968cfd0 | 2003-04-19 21:45:34 +0000 | [diff] [blame] | 586 | } |
Reid Spencer | eaa06bb | 2005-02-26 22:00:32 +0000 | [diff] [blame] | 587 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 588 | bool Archive::isBitcodeArchive() { |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 589 | // Make sure the symTab has been loaded. In most cases this should have been |
| 590 | // done when the archive was constructed, but still, this is just in case. |
| 591 | if (!symTab.size()) |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 592 | if (!loadSymbolTable(0)) |
| 593 | return false; |
Reid Spencer | eaa06bb | 2005-02-26 22:00:32 +0000 | [diff] [blame] | 594 | |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 595 | // Now that we know it's been loaded, return true |
| 596 | // if it has a size |
| 597 | if (symTab.size()) return true; |
Reid Spencer | eaa06bb | 2005-02-26 22:00:32 +0000 | [diff] [blame] | 598 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 599 | // We still can't be sure it isn't a bitcode archive |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 600 | if (!loadArchive(0)) |
| 601 | return false; |
Reid Spencer | eaa06bb | 2005-02-26 22:00:32 +0000 | [diff] [blame] | 602 | |
| 603 | std::vector<Module *> Modules; |
| 604 | std::string ErrorMessage; |
| 605 | |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 606 | // Scan the archive, trying to load a bitcode member. We only load one to |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 607 | // see if this works. |
| 608 | for (iterator I = begin(), E = end(); I != E; ++I) { |
Gabor Greif | e75ca3d | 2007-07-06 13:38:17 +0000 | [diff] [blame] | 609 | if (!I->isBitcode()) |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 610 | continue; |
| 611 | |
| 612 | std::string FullMemberName = |
| 613 | archPath.toString() + "(" + I->getPath().toString() + ")"; |
Chris Lattner | c1d5624 | 2007-05-06 09:28:33 +0000 | [diff] [blame] | 614 | |
| 615 | MemoryBuffer *Buffer = |
| 616 | MemoryBuffer::getNewMemBuffer(I->getSize(), FullMemberName.c_str()); |
| 617 | memcpy((char*)Buffer->getBufferStart(), I->getData(), I->getSize()); |
| 618 | Module *M = ParseBitcodeFile(Buffer); |
| 619 | delete Buffer; |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 620 | if (!M) |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 621 | return false; // Couldn't parse bitcode, not a bitcode archive. |
Chris Lattner | 7c43992 | 2005-09-23 06:22:58 +0000 | [diff] [blame] | 622 | delete M; |
| 623 | return true; |
| 624 | } |
| 625 | |
| 626 | return false; |
Reid Spencer | eaa06bb | 2005-02-26 22:00:32 +0000 | [diff] [blame] | 627 | } |