Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 1 | //===- GNUArchiveReader.cpp -----------------------------------------------===// |
| 2 | // |
| 3 | // The MCLinker Project |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 9 | #include <mcld/MC/MCLDInfo.h> |
| 10 | #include <mcld/MC/MCLDInput.h> |
| 11 | #include <mcld/MC/InputTree.h> |
| 12 | #include <mcld/LD/GNUArchiveReader.h> |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 13 | #include <mcld/LD/ResolveInfo.h> |
| 14 | #include <mcld/LD/ELFObjectReader.h> |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 15 | #include <mcld/Support/FileSystem.h> |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 16 | #include <mcld/Support/FileHandle.h> |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 17 | #include <mcld/Support/MemoryArea.h> |
| 18 | #include <mcld/Support/MemoryRegion.h> |
| 19 | #include <mcld/Support/MemoryAreaFactory.h> |
| 20 | #include <mcld/Support/MsgHandling.h> |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 21 | #include <mcld/Support/Path.h> |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 22 | #include <mcld/ADT/SizeTraits.h> |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 23 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 24 | #include <llvm/ADT/StringRef.h> |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 25 | #include <llvm/Support/Host.h> |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 26 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 27 | #include <cstring> |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 28 | #include <cstdlib> |
| 29 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 30 | using namespace mcld; |
| 31 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 32 | GNUArchiveReader::GNUArchiveReader(MCLDInfo& pLDInfo, |
| 33 | MemoryAreaFactory& pMemAreaFactory, |
| 34 | ELFObjectReader& pELFObjectReader) |
| 35 | : m_LDInfo(pLDInfo), |
| 36 | m_MemAreaFactory(pMemAreaFactory), |
| 37 | m_ELFObjectReader(pELFObjectReader) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 38 | { |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 41 | GNUArchiveReader::~GNUArchiveReader() |
| 42 | { |
| 43 | } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 44 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 45 | /// isMyFormat |
| 46 | bool GNUArchiveReader::isMyFormat(Input& pInput) const |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 47 | { |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 48 | assert(pInput.hasMemArea()); |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 49 | MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(), |
| 50 | Archive::MAGIC_LEN); |
| 51 | const char* str = reinterpret_cast<const char*>(region->getBuffer()); |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 52 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 53 | bool result = false; |
| 54 | assert(NULL != str); |
| 55 | if (isArchive(str) || isThinArchive(str)) |
| 56 | result = true; |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 57 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 58 | pInput.memArea()->release(region); |
| 59 | return result; |
| 60 | } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 61 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 62 | /// isArchive |
| 63 | bool GNUArchiveReader::isArchive(const char* pStr) const |
| 64 | { |
| 65 | return (0 == memcmp(pStr, Archive::MAGIC, Archive::MAGIC_LEN)); |
| 66 | } |
| 67 | |
| 68 | /// isThinArchive |
| 69 | bool GNUArchiveReader::isThinArchive(const char* pStr) const |
| 70 | { |
| 71 | return (0 == memcmp(pStr, Archive::THIN_MAGIC, Archive::MAGIC_LEN)); |
| 72 | } |
| 73 | |
| 74 | /// isThinArchive |
| 75 | bool GNUArchiveReader::isThinArchive(Input& pInput) const |
| 76 | { |
| 77 | assert(pInput.hasMemArea()); |
| 78 | MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(), |
| 79 | Archive::MAGIC_LEN); |
| 80 | const char* str = reinterpret_cast<const char*>(region->getBuffer()); |
| 81 | |
| 82 | bool result = false; |
| 83 | assert(NULL != str); |
| 84 | if (isThinArchive(str)) |
| 85 | result = true; |
| 86 | |
| 87 | pInput.memArea()->release(region); |
| 88 | return result; |
| 89 | } |
| 90 | |
| 91 | bool GNUArchiveReader::readArchive(Archive& pArchive) |
| 92 | { |
| 93 | // read the symtab of the archive |
| 94 | readSymbolTable(pArchive); |
| 95 | |
| 96 | // read the strtab of the archive |
| 97 | readStringTable(pArchive); |
| 98 | |
| 99 | // add root archive to ArchiveMemberMap |
| 100 | pArchive.addArchiveMember(pArchive.getARFile().name(), |
| 101 | pArchive.inputs().root(), |
| 102 | &InputTree::Downward); |
| 103 | |
| 104 | // include the needed members in the archive and build up the input tree |
| 105 | bool willSymResolved; |
| 106 | do { |
| 107 | willSymResolved = false; |
| 108 | for (size_t idx = 0; idx < pArchive.numOfSymbols(); ++idx) { |
| 109 | // bypass if we already decided to include this symbol or not |
| 110 | if (Archive::Symbol::Unknown != pArchive.getSymbolStatus(idx)) |
| 111 | continue; |
| 112 | |
| 113 | // bypass if another symbol with the same object file offset is included |
| 114 | if (pArchive.hasObjectMember(pArchive.getObjFileOffset(idx))) { |
| 115 | pArchive.setSymbolStatus(idx, Archive::Symbol::Include); |
| 116 | continue; |
| 117 | } |
| 118 | |
| 119 | // check if we should include this defined symbol |
| 120 | Archive::Symbol::Status status = |
| 121 | shouldIncludeSymbol(pArchive.getSymbolName(idx)); |
| 122 | if (Archive::Symbol::Unknown != status) |
| 123 | pArchive.setSymbolStatus(idx, status); |
| 124 | |
| 125 | if (Archive::Symbol::Include == status) { |
| 126 | Input* cur_archive = &(pArchive.getARFile()); |
| 127 | Input* member = cur_archive; |
| 128 | uint32_t file_offset = pArchive.getObjFileOffset(idx); |
| 129 | while ((member != NULL) && (Input::Object != member->type())) { |
| 130 | uint32_t nested_offset = 0; |
| 131 | // use the file offset in current archive to find out the member we |
| 132 | // want to include |
| 133 | member = readMemberHeader(pArchive, |
| 134 | *cur_archive, |
| 135 | file_offset, |
| 136 | nested_offset); |
| 137 | assert(member != NULL); |
| 138 | // bypass if we get an archive that is already in the map |
| 139 | if (Input::Archive == member->type()) { |
| 140 | cur_archive = member; |
| 141 | file_offset = nested_offset; |
| 142 | continue; |
| 143 | } |
| 144 | |
| 145 | // insert a node into the subtree of current archive. |
| 146 | Archive::ArchiveMember* parent = |
| 147 | pArchive.getArchiveMember(cur_archive->name()); |
| 148 | |
| 149 | assert(NULL != parent); |
| 150 | pArchive.inputs().insert(parent->lastPos, *(parent->move), *member); |
| 151 | |
| 152 | // move the iterator to new created node, and also adjust the |
| 153 | // direction to Afterward for next insertion in this subtree |
| 154 | parent->move->move(parent->lastPos); |
| 155 | parent->move = &InputTree::Afterward; |
| 156 | |
| 157 | if (m_ELFObjectReader.isMyFormat(*member)) { |
| 158 | member->setType(Input::Object); |
| 159 | pArchive.addObjectMember(pArchive.getObjFileOffset(idx), |
| 160 | parent->lastPos); |
| 161 | m_ELFObjectReader.readObject(*member); |
| 162 | m_ELFObjectReader.readSections(*member); |
| 163 | m_ELFObjectReader.readSymbols(*member); |
| 164 | } |
| 165 | else if (isMyFormat(*member)) { |
| 166 | member->setType(Input::Archive); |
| 167 | // when adding a new archive node, set the iterator to archive |
| 168 | // itself, and set the direction to Downward |
| 169 | pArchive.addArchiveMember(member->name(), |
| 170 | parent->lastPos, |
| 171 | &InputTree::Downward); |
| 172 | cur_archive = member; |
| 173 | file_offset = nested_offset; |
| 174 | } |
| 175 | } // end of while |
| 176 | willSymResolved = true; |
| 177 | } // end of if |
| 178 | } // end of for |
| 179 | } while (willSymResolved); |
| 180 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 181 | return true; |
| 182 | } |
| 183 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 184 | /// readMemberHeader - read the header of a member in a archive file and then |
| 185 | /// return the corresponding archive member (it may be an input object or |
| 186 | /// another archive) |
| 187 | /// @param pArchiveRoot - the archive root that holds the strtab (extended |
| 188 | /// name table) |
| 189 | /// @param pArchiveFile - the archive that contains the needed object |
| 190 | /// @param pFileOffset - file offset of the member header in the archive |
| 191 | /// @param pNestedOffset - used when we find a nested archive |
| 192 | Input* GNUArchiveReader::readMemberHeader(Archive& pArchiveRoot, |
| 193 | Input& pArchiveFile, |
| 194 | uint32_t pFileOffset, |
| 195 | uint32_t& pNestedOffset) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 196 | { |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 197 | assert(pArchiveFile.hasMemArea()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 198 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 199 | MemoryRegion* header_region = |
| 200 | pArchiveFile.memArea()->request((pArchiveFile.fileOffset() + pFileOffset), |
| 201 | sizeof(Archive::MemberHeader)); |
| 202 | const Archive::MemberHeader* header = |
| 203 | reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 204 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 205 | assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2)); |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 206 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 207 | // int size = atoi(header->size); |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 208 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 209 | // parse the member name and nested offset if any |
| 210 | std::string member_name; |
| 211 | llvm::StringRef name_field(header->name, 16); |
| 212 | if ('/' != header->name[0]) { |
| 213 | // this is an object file in an archive |
| 214 | size_t pos = name_field.find_first_of('/'); |
| 215 | member_name.assign(name_field.substr(0, pos).str()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 216 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 217 | else { |
| 218 | // this is an object/archive file in a thin archive |
| 219 | size_t begin = 1; |
| 220 | size_t end = name_field.find_first_of(" :"); |
| 221 | uint32_t name_offset = 0; |
| 222 | // parse the name offset |
| 223 | name_field.substr(begin, end - begin).getAsInteger(10, name_offset); |
| 224 | |
| 225 | if (':' == name_field[end]) { |
| 226 | // there is a nested offset |
| 227 | begin = end + 1; |
| 228 | end = name_field.find_first_of(' ', begin); |
| 229 | name_field.substr(begin, end - begin).getAsInteger(10, pNestedOffset); |
| 230 | } |
| 231 | |
| 232 | // get the member name from the extended name table |
| 233 | begin = name_offset; |
| 234 | end = pArchiveRoot.getStrTable().find_first_of('\n', begin); |
| 235 | member_name.assign(pArchiveRoot.getStrTable().substr(begin, end - begin -1)); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 236 | } |
| 237 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 238 | Input* member = NULL; |
| 239 | if (!isThinArchive(pArchiveFile)) { |
| 240 | // this is an object file in an archive |
| 241 | member = |
| 242 | m_LDInfo.inputFactory().produce(member_name, |
| 243 | pArchiveFile.path(), |
| 244 | Input::Unknown, |
| 245 | (pFileOffset + |
| 246 | sizeof(Archive::MemberHeader))); |
| 247 | assert(member != NULL); |
| 248 | member->setMemArea(pArchiveFile.memArea()); |
| 249 | LDContext *input_context = m_LDInfo.contextFactory().produce(); |
| 250 | member->setContext(input_context); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 251 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 252 | else { |
| 253 | // this is a member in a thin archive |
| 254 | // try to find if this is a archive already in the map first |
| 255 | Archive::ArchiveMember* ar_member = |
| 256 | pArchiveRoot.getArchiveMember(member_name); |
| 257 | if (NULL != ar_member) { |
| 258 | return ar_member->file; |
| 259 | } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 260 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 261 | // get nested file path, the nested file's member name is the relative |
| 262 | // path to the archive containing it. |
| 263 | sys::fs::Path input_path(pArchiveFile.path().parent_path()); |
| 264 | if (!input_path.empty()) |
| 265 | input_path.append(member_name); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 266 | else |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 267 | input_path.assign(member_name); |
| 268 | member = |
| 269 | m_LDInfo.inputFactory().produce(member_name, input_path, Input::Unknown); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 270 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 271 | assert(member != NULL); |
| 272 | MemoryArea* input_memory = |
| 273 | m_MemAreaFactory.produce(member->path(), FileHandle::ReadOnly); |
| 274 | if (input_memory->handler()->isGood()) { |
| 275 | member->setMemArea(input_memory); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 276 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 277 | else { |
| 278 | error(diag::err_cannot_open_input) << member->name() << member->path(); |
| 279 | return NULL; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 280 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 281 | LDContext *input_context = m_LDInfo.contextFactory().produce(input_path); |
| 282 | member->setContext(input_context); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 283 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 284 | |
| 285 | pArchiveFile.memArea()->release(header_region); |
| 286 | return member; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 287 | } |
| 288 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 289 | /// readSymbolTable - read the archive symbol map (armap) |
| 290 | bool GNUArchiveReader::readSymbolTable(Archive& pArchive) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 291 | { |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 292 | assert(pArchive.getARFile().hasMemArea()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 293 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 294 | MemoryRegion* header_region = |
| 295 | pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() + |
| 296 | Archive::MAGIC_LEN), |
| 297 | sizeof(Archive::MemberHeader)); |
| 298 | const Archive::MemberHeader* header = |
| 299 | reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer()); |
| 300 | assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2)); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 301 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 302 | int symtab_size = atoi(header->size); |
| 303 | pArchive.setSymTabSize(symtab_size); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 304 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 305 | MemoryRegion* symtab_region = |
| 306 | pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() + |
| 307 | Archive::MAGIC_LEN + |
| 308 | sizeof(Archive::MemberHeader)), |
| 309 | symtab_size); |
| 310 | const uint32_t* data = |
| 311 | reinterpret_cast<const uint32_t*>(symtab_region->getBuffer()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 312 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 313 | // read the number of symbols |
| 314 | uint32_t number = 0; |
| 315 | if (llvm::sys::isLittleEndianHost()) |
| 316 | number = bswap32(*data); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 317 | else |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 318 | number = *data; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 319 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 320 | // set up the pointers for file offset and name offset |
| 321 | ++data; |
| 322 | const char* name = reinterpret_cast<const char*>(data + number); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 323 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 324 | // add the archive symbols |
| 325 | for (uint32_t i = 0; i < number; ++i) { |
| 326 | if (llvm::sys::isLittleEndianHost()) |
| 327 | pArchive.addSymbol(name, bswap32(*data)); |
| 328 | else |
| 329 | pArchive.addSymbol(name, *data); |
| 330 | name += strlen(name) + 1; |
| 331 | ++data; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 332 | } |
| 333 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 334 | pArchive.getARFile().memArea()->release(header_region); |
| 335 | pArchive.getARFile().memArea()->release(symtab_region); |
| 336 | return true; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 337 | } |
| 338 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 339 | /// readStringTable - read the strtab for long file name of the archive |
| 340 | bool GNUArchiveReader::readStringTable(Archive& pArchive) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 341 | { |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 342 | size_t offset = Archive::MAGIC_LEN + |
| 343 | sizeof(Archive::MemberHeader) + |
| 344 | pArchive.getSymTabSize(); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 345 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 346 | if (0x0 != (offset & 1)) |
| 347 | ++offset; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 348 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 349 | assert(pArchive.getARFile().hasMemArea()); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 350 | |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 351 | MemoryRegion* header_region = |
| 352 | pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() + |
| 353 | offset), |
| 354 | sizeof(Archive::MemberHeader)); |
| 355 | const Archive::MemberHeader* header = |
| 356 | reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer()); |
| 357 | |
| 358 | assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2)); |
| 359 | |
| 360 | int strtab_size = atoi(header->size); |
| 361 | |
| 362 | MemoryRegion* strtab_region = |
| 363 | pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() + |
| 364 | offset + |
| 365 | sizeof(Archive::MemberHeader)), |
| 366 | strtab_size); |
| 367 | const char* strtab = |
| 368 | reinterpret_cast<const char*>(strtab_region->getBuffer()); |
| 369 | |
| 370 | pArchive.getStrTable().assign(strtab, strtab_size); |
| 371 | |
| 372 | pArchive.getARFile().memArea()->release(header_region); |
| 373 | pArchive.getARFile().memArea()->release(strtab_region); |
| 374 | return true; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 375 | } |
Shih-wei Liao | cedee4b | 2012-08-02 23:13:03 -0700 | [diff] [blame^] | 376 | |
| 377 | /// shouldIncludeStatus - given a sym name from armap and check if including |
| 378 | /// the corresponding archive member, and then return the decision |
| 379 | enum Archive::Symbol::Status |
| 380 | GNUArchiveReader::shouldIncludeSymbol(const llvm::StringRef& pSymName) const |
| 381 | { |
| 382 | // TODO: handle symbol version issue and user defined symbols |
| 383 | ResolveInfo* info = m_LDInfo.getNamePool().findInfo(pSymName); |
| 384 | if (NULL != info) { |
| 385 | if (!info->isUndef()) |
| 386 | return Archive::Symbol::Exclude; |
| 387 | if (info->isWeak()) |
| 388 | return Archive::Symbol::Unknown; |
| 389 | return Archive::Symbol::Include; |
| 390 | } |
| 391 | return Archive::Symbol::Unknown; |
| 392 | } |
| 393 | |