git.saurik.com Git - apple/ld64.git/blob - src/ld/parsers/archive

1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-

2 *

4 *

5 * @APPLE_LICENSE_HEADER_START@

6 *

7 * This file contains Original Code and/or Modifications of Original Code

8 * as defined in and that are subject to the Apple Public Source License

9 * Version 2.0 (the 'License'). You may not use this file except in

10 * compliance with the License. Please obtain a copy of the License at

11 * http://www.opensource.apple.com/apsl/ and read it before using this

12 * file.

13 *

14 * The Original Code and all software distributed under the License are

15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,

17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.

19 * Please see the License for the specific language governing rights and

20 * limitations under the License.

21 *

22 * @APPLE_LICENSE_HEADER_END@

23 */

25 #include <stdint.h>

26 #include <math.h>

27 #include <unistd.h>

28 #include <sys/param.h>

29 #include <mach-o/ranlib.h>

30 #include <ar.h>

32 #include <vector>

33 #include <set>

34 #include <map>

35 #include <algorithm>

36 #include <unordered_map>

38 #include "MachOFileAbstraction.hpp"

39 #include "Architectures.hpp"

41 #include "macho_relocatable_file.h"

42 #include "lto_file.h"

43 #include "archive_file.h"

46 namespace archive {

49 // forward reference

 template <typename A> class File;

53 template <typename A>

54 class Parser

55 {

56 public:

57 typedef typename A::P P;

         static bool                                                                             validFile(const uint8_t* fileContent, uint64_t fileLength, 

                                                                                                                                 const mach_o::relocatable::ParserOptions& opts) {

                                                                                                                 return File<A>::validFile(fileContent, fileLength, opts); }

         static File<A>*                                                                 parse(const uint8_t* fileContent, uint64_t fileLength, 

                                                                                                                         const char* path, time_t mTime, 

                                                                                                                         ld::File::Ordinal ordinal, const ParserOptions& opts) {

                                                                                                                          return new File<A>(fileContent, fileLength, path, mTime,

66 ordinal, opts);

67 }

69 };

71 template <typename A>

 class File : public ld::archive::File

73 {

74 public:

         static bool                                                                             validFile(const uint8_t* fileContent, uint64_t fileLength,

                                                                                                                                 const mach_o::relocatable::ParserOptions& opts);

                                                                                                         File(const uint8_t* fileContent, uint64_t fileLength,

                                                                                                                         const char* pth, time_t modTime, 

                                                                                                                         ld::File::Ordinal ord, const ParserOptions& opts);

80 virtual ~File() {}

82 // overrides of ld::File

         virtual bool                                                                            forEachAtom(ld::File::AtomHandler&) const;

         virtual bool                                                                            justInTimeforEachAtom(const char* name, ld::File::AtomHandler&) const;

         virtual uint32_t                                                                        subFileCount() const  { return _archiveFilelength/sizeof(ar_hdr); }

87 // overrides of ld::archive::File

         virtual bool                                                                            justInTimeDataOnlyforEachAtom(const char* name, ld::File::AtomHandler& handler) const;

90 private:

         static bool                                                                             validMachOFile(const uint8_t* fileContent, uint64_t fileLength, 

                                                                                                                                         const mach_o::relocatable::ParserOptions& opts);

         static bool                                                                             validLTOFile(const uint8_t* fileContent, uint64_t fileLength, 

                                                                                                                                         const mach_o::relocatable::ParserOptions& opts);

95 static cpu_type_t architecture();

97 class Entry : ar_hdr

98 {

99 public:

                 void                            getName(char *, int) const;

                 time_t                          modificationTime() const;

                 const uint8_t*          content() const;

                 uint32_t                        contentSize() const;

                 const Entry*            next() const;

105 private:

                 bool                            hasLongName() const;

                 unsigned int            getLongNameSpace() const;

108

109 };

110

         struct MemberState { ld::relocatable::File* file; const Entry *entry; bool logged; bool loaded; uint32_t index;};

         bool                                                                                    loadMember(MemberState& state, ld::File::AtomHandler& handler, const char *format, ...) const;

113

         typedef std::unordered_map<const char*, uint64_t, ld::CStringHash, ld::CStringEquals> NameToOffsetMap;

115

116 typedef typename A::P P;

         typedef typename A::P::E                                                E;

118

         typedef std::map<const class Entry*, MemberState> MemberToStateMap;

120

         MemberState&                                                                    makeObjectFileForMember(const Entry* member) const;

         bool                                                                                    memberHasObjCCategories(const Entry* member) const;

123 void dumpTableOfContents();

124 void buildHashTable();

125 #ifdef SYMDEF_64

126 void buildHashTable64();

127 #endif

128 const uint8_t* _archiveFileContent;

129 uint64_t _archiveFilelength;

130 const struct ranlib* _tableOfContents;

131 #ifdef SYMDEF_64

132 const struct ranlib_64* _tableOfContents64;

133 #endif

134 uint32_t _tableOfContentCount;

135 const char* _tableOfContentStrings;

136 mutable MemberToStateMap _instantiatedEntries;

137 NameToOffsetMap _hashTable;

138 const bool _forceLoadAll;

139 const bool _forceLoadObjC;

140 const bool _forceLoadThis;

141 const bool _objc2ABI;

142 const bool _verboseLoad;

143 const bool _logAllFiles;

         const mach_o::relocatable::ParserOptions                _objOpts;

145 };

146

147

148 template <typename A>

 bool File<A>::Entry::hasLongName() const

150 {

         return ( strncmp(this->ar_name, AR_EFMT1, strlen(AR_EFMT1)) == 0 );

152 }

153

154 template <typename A>

 unsigned int File<A>::Entry::getLongNameSpace() const

156 {

157 char* endptr;

         long result = strtol(&this->ar_name[strlen(AR_EFMT1)], &endptr, 10);

159 return result;

160 }

161

162 template <typename A>

 void File<A>::Entry::getName(char *buf, int bufsz) const

164 {

         if ( this->hasLongName() ) {

                 int len = this->getLongNameSpace();

                 assert(bufsz >= len+1);

                 strncpy(buf, ((char*)this)+sizeof(ar_hdr), len);

169 buf[len] = '\0';

170 }

171 else {

                 assert(bufsz >= 16+1);

                 strncpy(buf, this->ar_name, 16);

                 buf[16] = '\0';

                 char* space = strchr(buf, ' ');

176 if ( space != NULL )

177 *space = '\0';

178 }

179 }

180

181 template <typename A>

 time_t  File<A>::Entry::modificationTime() const

183 {

184 char temp[14];

         strncpy(temp, this->ar_date, 12);

         temp[12] = '\0';

187 char* endptr;

         return (time_t)strtol(temp, &endptr, 10);

189 }

190

191

192 template <typename A>

 const uint8_t* File<A>::Entry::content() const

194 {

         if ( this->hasLongName() )

                 return ((uint8_t*)this) + sizeof(ar_hdr) + this->getLongNameSpace();

197 else

                 return ((uint8_t*)this) + sizeof(ar_hdr);

199 }

200

201

202 template <typename A>

 uint32_t File<A>::Entry::contentSize() const

204 {

205 char temp[12];

         strncpy(temp, this->ar_size, 10);

         temp[10] = '\0';

208 char* endptr;

         long size = strtol(temp, &endptr, 10);

210 // long name is included in ar_size

         if ( this->hasLongName() )

                 size -= this->getLongNameSpace();

213 return size;

214 }

215

216

217 template <typename A>

 const class File<A>::Entry* File<A>::Entry::next() const

219 {

         const uint8_t* p = this->content() + contentSize();

         p = (const uint8_t*)(((uintptr_t)p+3) & (-4));  // 4-byte align

         return (class File<A>::Entry*)p;

223 }

224

225

 template <> cpu_type_t File<x86>::architecture()    { return CPU_TYPE_I386; }

 template <> cpu_type_t File<x86_64>::architecture() { return CPU_TYPE_X86_64; }

 template <> cpu_type_t File<arm>::architecture()    { return CPU_TYPE_ARM; }

 template <> cpu_type_t File<arm64>::architecture()  { return CPU_TYPE_ARM64; }

230

231 template <typename A>

 bool File<A>::validMachOFile(const uint8_t* fileContent, uint64_t fileLength, const mach_o::relocatable::ParserOptions& opts)

233 {

         return mach_o::relocatable::isObjectFile(fileContent, fileLength, opts);

235 }

236

237 template <typename A>

 bool File<A>::validLTOFile(const uint8_t* fileContent, uint64_t fileLength, const mach_o::relocatable::ParserOptions& opts)

239 {

         return lto::isObjectFile(fileContent, fileLength, opts.architecture, opts.subType);

241 }

242

243

244

245 template <typename A>

 bool File<A>::validFile(const uint8_t* fileContent, uint64_t fileLength, const mach_o::relocatable::ParserOptions& opts)

247 {

248 // must have valid archive header

         if ( strncmp((const char*)fileContent, "!<arch>\n", 8) != 0 )

250 return false;

251

252 // peak at first .o file and verify it is correct architecture

         const Entry* const start = (Entry*)&fileContent[8];

         const Entry* const end = (Entry*)&fileContent[fileLength];

         for (const Entry* p=start; p < end; p = p->next()) {

256 char memberName[256];

                 p->getName(memberName, sizeof(memberName));

258 // skip option table-of-content member

                 if ( (p==start) && ((strcmp(memberName, SYMDEF_SORTED) == 0) || (strcmp(memberName, SYMDEF) == 0)) )

260 continue;

261 #ifdef SYMDEF_64

                 if ( (p==start) && ((strcmp(memberName, SYMDEF_64_SORTED) == 0) || (strcmp(memberName, SYMDEF_64) == 0)) )

263 continue;

264 #endif

265 // archive is valid if first .o file is valid

                 return (validMachOFile(p->content(), p->contentSize(), opts) || validLTOFile(p->content(), p->contentSize(), opts));

267 }

268 // empty archive

269 return true;

270 }

271

272

273 template <typename A>

 File<A>::File(const uint8_t fileContent[], uint64_t fileLength, const char* pth, time_t modTime, 

                                         ld::File::Ordinal ord, const ParserOptions& opts)

  : ld::archive::File(strdup(pth), modTime, ord),

         _archiveFileContent(fileContent), _archiveFilelength(fileLength), 

278 _tableOfContents(NULL),

279 #ifdef SYMDEF_64

280 _tableOfContents64(NULL),

281 #endif

         _tableOfContentCount(0), _tableOfContentStrings(NULL),

         _forceLoadAll(opts.forceLoadAll), _forceLoadObjC(opts.forceLoadObjC), 

         _forceLoadThis(opts.forceLoadThisArchive), _objc2ABI(opts.objcABI2), _verboseLoad(opts.verboseLoad), 

         _logAllFiles(opts.logAllFiles), _objOpts(opts.objOpts)

286 {

         if ( strncmp((const char*)fileContent, "!<arch>\n", 8) != 0 )

288 throw "not an archive";

289

290 if ( !_forceLoadAll ) {

                 const Entry* const firstMember = (Entry*)&_archiveFileContent[8];

292 char memberName[256];

                 firstMember->getName(memberName, sizeof(memberName));

                 if ( (strcmp(memberName, SYMDEF_SORTED) == 0) || (strcmp(memberName, SYMDEF) == 0) ) {

                         const uint8_t* contents = firstMember->content();

                         uint32_t ranlibArrayLen = E::get32(*((uint32_t*)contents));

                         _tableOfContents = (const struct ranlib*)&contents[4];

                         _tableOfContentCount = ranlibArrayLen / sizeof(struct ranlib);

                         _tableOfContentStrings = (const char*)&contents[ranlibArrayLen+8];

                         if ( ((uint8_t*)(&_tableOfContents[_tableOfContentCount]) > &fileContent[fileLength])

                                 || ((uint8_t*)_tableOfContentStrings > &fileContent[fileLength]) )

302 throw "malformed archive, perhaps wrong architecture";

303 this->buildHashTable();

304 }

305 #ifdef SYMDEF_64

                 else if ( (strcmp(memberName, SYMDEF_64_SORTED) == 0) || (strcmp(memberName, SYMDEF_64) == 0) ) {

                         const uint8_t* contents = firstMember->content();

                         uint64_t ranlibArrayLen = E::get64(*((uint64_t*)contents));

                         _tableOfContents64 = (const struct ranlib_64*)&contents[8];

                         _tableOfContentCount = ranlibArrayLen / sizeof(struct ranlib_64);

                         _tableOfContentStrings = (const char*)&contents[ranlibArrayLen+16];

                         if ( ((uint8_t*)(&_tableOfContents[_tableOfContentCount]) > &fileContent[fileLength])

                                 || ((uint8_t*)_tableOfContentStrings > &fileContent[fileLength]) )

314 throw "malformed archive, perhaps wrong architecture";

315 this->buildHashTable64();

316 }

317 #endif

318 else

319 throw "archive has no table of contents";

320 }

321 }

322

323 template <>

 bool File<x86>::memberHasObjCCategories(const Entry* member) const

325 {

326 if ( _objc2ABI ) {

327 // i386 for iOS simulator uses ObjC2 which has no global symbol for categories

                 return mach_o::relocatable::hasObjC2Categories(member->content());

329 }

330 else {

331 // i386 uses ObjC1 ABI which has .objc_category* global symbols

332 // <rdar://problem/11342022> strip -S on i386 pulls out .objc_category_name symbols from static frameworks

                 return mach_o::relocatable::hasObjC1Categories(member->content());

334 }

335 }

336

337

338

339 template <typename A>

 bool File<A>::memberHasObjCCategories(const Entry* member) const

341 {

342 // x86_64 and ARM use ObjC2 which has no global symbol for categories

         return mach_o::relocatable::hasObjC2Categories(member->content());

344 }

345

346

347 template <typename A>

 typename File<A>::MemberState& File<A>::makeObjectFileForMember(const Entry* member) const

349 {

350 uint32_t memberIndex = 0;

351 // in case member was instantiated earlier but not needed yet

         typename MemberToStateMap::iterator pos = _instantiatedEntries.find(member);

         if ( pos == _instantiatedEntries.end() ) {

354 // Have to find the index of this member

355 const Entry* start;

356 uint32_t index;

                 if (_instantiatedEntries.size() == 0) {

                         start = (Entry*)&_archiveFileContent[8];

359 index = 1;

360 } else {

                         MemberState &lastKnown = _instantiatedEntries.rbegin()->second;

                         start = lastKnown.entry->next();

                         index = lastKnown.index+1;

364 }

                 for (const Entry* p=start; p <= member; p = p->next(), index++) {

                         MemberState state = {NULL, p, false, false, index};

367 _instantiatedEntries[p] = state;

368 if (member == p) {

369 memberIndex = index;

370 }

371 }

372 } else {

373 MemberState& state = pos->second;

374 if (state.file)

375 return state;

376 memberIndex = state.index;

377 }

         assert(memberIndex != 0);

379 char memberName[256];

         member->getName(memberName, sizeof(memberName));

         char memberPath[strlen(this->path()) + strlen(memberName)+4];

         strcpy(memberPath, this->path());

         strcat(memberPath, "(");

384 strcat(memberPath, memberName);

         strcat(memberPath, ")");

386 //fprintf(stderr, "using %s from %s\n", memberName, this->path());

387 try {

388 // range check

                 if ( member > (Entry*)(_archiveFileContent+_archiveFilelength) )

390 throwf("corrupt archive, member starts past end of file");

                 if ( (member->content() + member->contentSize()) > (_archiveFileContent+_archiveFilelength) )

392 throwf("corrupt archive, member contents extends past end of file");

                 const char* mPath = strdup(memberPath);

394 // see if member is mach-o file

                 ld::File::Ordinal ordinal = this->ordinal().archiveOrdinalWithMemberIndex(memberIndex);

                 ld::relocatable::File* result = mach_o::relocatable::parse(member->content(), member->contentSize(), 

397 mPath, member->modificationTime(),

398 ordinal, _objOpts);

399 if ( result != NULL ) {

                         MemberState state = {result, member, false, false, memberIndex};

401 _instantiatedEntries[member] = state;

402 return _instantiatedEntries[member];

403 }

404 // see if member is llvm bitcode file

                 result = lto::parse(member->content(), member->contentSize(), 

                                                                 mPath, member->modificationTime(), ordinal, 

                                                                 _objOpts.architecture, _objOpts.subType, _logAllFiles, _objOpts.verboseOptimizationHints);

408 if ( result != NULL ) {

                         MemberState state = {result, member, false, false, memberIndex};

410 _instantiatedEntries[member] = state;

411 return _instantiatedEntries[member];

412 }

413

                 throwf("archive member '%s' with length %d is not mach-o or llvm bitcode", memberName, member->contentSize());

415 }

         catch (const char* msg) {

                 throwf("in %s, %s", memberPath, msg);

418 }

419 }

420

421

422 template <typename A>

 bool File<A>::loadMember(MemberState& state, ld::File::AtomHandler& handler, const char *format, ...) const

424 {

425 bool didSomething = false;

426 if (!state.loaded) {

                 if ( _verboseLoad && !state.logged ) {

428 va_list list;

429 va_start(list, format);

430 vprintf(format, list);

431 va_end(list);

432 state.logged = true;

433 }

434 state.loaded = true;

                 didSomething = state.file->forEachAtom(handler);

436 }

437 return didSomething;

438 }

439

440

441 template <typename A>

 bool File<A>::forEachAtom(ld::File::AtomHandler& handler) const

443 {

444 bool didSome = false;

445 if ( _forceLoadAll || _forceLoadThis ) {

446 // call handler on all .o files in this archive

                 const Entry* const start = (Entry*)&_archiveFileContent[8];

                 const Entry* const end = (Entry*)&_archiveFileContent[_archiveFilelength];

                 for (const Entry* p=start; p < end; p = p->next()) {

450 char memberName[256];

                         p->getName(memberName, sizeof(memberName));

                         if ( (p==start) && ((strcmp(memberName, SYMDEF_SORTED) == 0) || (strcmp(memberName, SYMDEF) == 0)) )

453 continue;

454 #ifdef SYMDEF_64

                         if ( (p==start) && ((strcmp(memberName, SYMDEF_64_SORTED) == 0) || (strcmp(memberName, SYMDEF_64) == 0)) )

456 continue;

457 #endif

                         MemberState& state = this->makeObjectFileForMember(p);

                         didSome |= loadMember(state, handler, "%s forced load of %s(%s)\n", _forceLoadThis ? "-force_load" : "-all_load", this->path(), memberName);

460 }

461 }

462 else if ( _forceLoadObjC ) {

463 // call handler on all .o files in this archive containing objc classes

                 for (const auto& entry : _hashTable) {

                         if ( (strncmp(entry.first, ".objc_c", 7) == 0) || (strncmp(entry.first, "_OBJC_CLASS_$_", 14) == 0) ) {

                                 const Entry* member = (Entry*)&_archiveFileContent[entry.second];

                                 MemberState& state = this->makeObjectFileForMember(member);

468 char memberName[256];

                                 member->getName(memberName, sizeof(memberName));

                                 didSome |= loadMember(state, handler, "-ObjC forced load of %s(%s)\n", this->path(), memberName);

471 }

472 }

473 // ObjC2 has no symbols in .o files with categories but not classes, look deeper for those

                 const Entry* const start = (Entry*)&_archiveFileContent[8];

                 const Entry* const end = (Entry*)&_archiveFileContent[_archiveFilelength];

                 for (const Entry* member=start; member < end; member = member->next()) {

477 char mname[256];

                         member->getName(mname, sizeof(mname));

479 // skip table-of-content member

                         if ( (member==start) && ((strcmp(mname, SYMDEF_SORTED) == 0) || (strcmp(mname, SYMDEF) == 0)) )

481 continue;

482 #ifdef SYMDEF_64

                         if ( (member==start) && ((strcmp(mname, SYMDEF_64_SORTED) == 0) || (strcmp(mname, SYMDEF_64) == 0)) )

484 continue;

485 #endif

                         if ( validMachOFile(member->content(), member->contentSize(), _objOpts) ) {

                                 MemberState& state = this->makeObjectFileForMember(member);

488 // only look at files not already loaded

489 if ( ! state.loaded ) {

                                         if ( this->memberHasObjCCategories(member) ) {

                                                 MemberState& state = this->makeObjectFileForMember(member);

492 char memberName[256];

                                                 member->getName(memberName, sizeof(memberName));

                                                 didSome |= loadMember(state, handler, "-ObjC forced load of %s(%s)\n", this->path(), memberName);

495 }

496 }

497 }

                         else if ( validLTOFile(member->content(), member->contentSize(), _objOpts) ) {

                                 if ( lto::hasObjCCategory(member->content(), member->contentSize()) ) {

                                         MemberState& state = this->makeObjectFileForMember(member);

501 // only look at files not already loaded

502 if ( ! state.loaded ) {

503 char memberName[256];

                                                 member->getName(memberName, sizeof(memberName));

                                                 didSome |= loadMember(state, handler, "-ObjC forced load of %s(%s)\n", this->path(), memberName);

506 }

507 }

508 }

509 }

510 }

511 return didSome;

512 }

513

514 template <typename A>

 bool File<A>::justInTimeforEachAtom(const char* name, ld::File::AtomHandler& handler) const

516 {

517 // in force load case, all members already loaded

518 if ( _forceLoadAll || _forceLoadThis )

519 return false;

520

521 // do a hash search of table of contents looking for requested symbol

         const auto& pos = _hashTable.find(name);

         if ( pos == _hashTable.end() )

524 return false;

525

526 // do a hash search of table of contents looking for requested symbol

         const Entry* member = (Entry*)&_archiveFileContent[pos->second];

         MemberState& state = this->makeObjectFileForMember(member);

529 char memberName[256];

         member->getName(memberName, sizeof(memberName));

         return loadMember(state, handler, "%s forced load of %s(%s)\n", name, this->path(), memberName);

532 }

533

 class CheckIsDataSymbolHandler : public ld::File::AtomHandler

535 {

536 public:

                                         CheckIsDataSymbolHandler(const char* n) : _name(n), _isData(false) {}

         virtual void    doAtom(const class ld::Atom& atom) {

                                                 if ( strcmp(atom.name(), _name) == 0 ) {

                                                         if ( atom.section().type() != ld::Section::typeCode )

541 _isData = true;

542 }

543 }

         virtual void    doFile(const class ld::File&) {}

         bool                    symbolIsDataDefinition() { return _isData; }

546

547 private:

548 const char* _name;

549 bool _isData;

550

551 };

552

553 template <typename A>

 bool File<A>::justInTimeDataOnlyforEachAtom(const char* name, ld::File::AtomHandler& handler) const

555 {

556 // in force load case, all members already loaded

557 if ( _forceLoadAll || _forceLoadThis )

558 return false;

559

560 // do a hash search of table of contents looking for requested symbol

         const auto& pos = _hashTable.find(name);

         if ( pos == _hashTable.end() )

563 return false;

564

         const Entry* member = (Entry*)&_archiveFileContent[pos->second];

         MemberState& state = this->makeObjectFileForMember(member);

567 // only call handler for each member once

568 if ( ! state.loaded ) {

569 CheckIsDataSymbolHandler checker(name);

                 state.file->forEachAtom(checker);

                 if ( checker.symbolIsDataDefinition() ) {

572 char memberName[256];

                         member->getName(memberName, sizeof(memberName));

                         return loadMember(state, handler, "%s forced load of %s(%s)\n", name, this->path(), memberName);

575 }

576 }

577

578 //fprintf(stderr, "%s NOT found in archive %s\n", name, this->path());

579 return false;

580 }

581

582 template <typename A>

 void File<A>::buildHashTable()

584 {

585 // walk through list backwards, adding/overwriting entries

586 // this assures that with duplicates those earliest in the list will be found

         for (int i = _tableOfContentCount-1; i >= 0; --i) {

                 const struct ranlib* entry = &_tableOfContents[i];

                 const char* entryName = &_tableOfContentStrings[E::get32(entry->ran_un.ran_strx)];

                 uint64_t offset = E::get32(entry->ran_off);

591 if ( offset > _archiveFilelength ) {

                         throwf("malformed archive TOC entry for %s, offset %d is beyond end of file %lld\n",

593 entryName, entry->ran_off, _archiveFilelength);

594 }

595

596 //const Entry* member = (Entry*)&_archiveFileContent[E::get32(entry->ran_off)];

597 //fprintf(stderr, "adding hash %d, %s -> %p\n", i, entryName, entry);

598 _hashTable[entryName] = offset;

599 }

600 }

601

602 #ifdef SYMDEF_64

603 template <typename A>

 void File<A>::buildHashTable64()

605 {

606 // walk through list backwards, adding/overwriting entries

607 // this assures that with duplicates those earliest in the list will be found

         for (int i = _tableOfContentCount-1; i >= 0; --i) {

                 const struct ranlib_64* entry = &_tableOfContents64[i];

                 const char* entryName = &_tableOfContentStrings[E::get64(entry->ran_un.ran_strx)];

                 uint64_t offset = E::get64(entry->ran_off);

612 if ( offset > _archiveFilelength ) {

                         throwf("malformed archive TOC entry for %s, offset %lld is beyond end of file %lld\n",

614 entryName, entry->ran_off, _archiveFilelength);

615 }

616

617 //fprintf(stderr, "adding hash %d: %s -> 0x%0llX\n", i, entryName, offset);

618 _hashTable[entryName] = offset;

619 }

620 }

621 #endif

622

623 template <typename A>

 void File<A>::dumpTableOfContents()

625 {

         for (unsigned int i=0; i < _tableOfContentCount; ++i) {

                 const struct ranlib* e = &_tableOfContents[i];

                 printf("%s in %s\n", &_tableOfContentStrings[E::get32(e->ran_un.ran_strx)], ((Entry*)&_archiveFileContent[E::get32(e->ran_off)])->name());

629 }

630 }

631

632

633 //

634 // main function used by linker to instantiate archive files

635 //

 ld::archive::File* parse(const uint8_t* fileContent, uint64_t fileLength, 

                                 const char* path, time_t modTime, ld::File::Ordinal ordinal, const ParserOptions& opts)

638 {

         switch ( opts.objOpts.architecture ) {

640 #if SUPPORT_ARCH_x86_64

641 case CPU_TYPE_X86_64:

                         if ( archive::Parser<x86_64>::validFile(fileContent, fileLength, opts.objOpts) )

                                 return archive::Parser<x86_64>::parse(fileContent, fileLength, path, modTime, ordinal, opts);

644 break;

645 #endif

646 #if SUPPORT_ARCH_i386

647 case CPU_TYPE_I386:

                         if ( archive::Parser<x86>::validFile(fileContent, fileLength, opts.objOpts) )

                                 return archive::Parser<x86>::parse(fileContent, fileLength, path, modTime, ordinal, opts);

650 break;

651 #endif

652 #if SUPPORT_ARCH_arm_any

653 case CPU_TYPE_ARM:

                         if ( archive::Parser<arm>::validFile(fileContent, fileLength, opts.objOpts) )

                                 return archive::Parser<arm>::parse(fileContent, fileLength, path, modTime, ordinal, opts);

656 break;

657 #endif

658 #if SUPPORT_ARCH_arm64

659 case CPU_TYPE_ARM64:

                         if ( archive::Parser<arm64>::validFile(fileContent, fileLength, opts.objOpts) )

                                 return archive::Parser<arm64>::parse(fileContent, fileLength, path, modTime, ordinal, opts);

662 break;

663 #endif

664 }

665 return NULL;

666 }

667

668

669

670 }; // namespace archive

671

672