ld64-236.3.tar.gz

[apple/ld64.git] / src / ld / parsers / archive_file.cpp

diff --git a/src/ld/parsers/archive_file.cpp b/src/ld/parsers/archive_file.cpp
index 8c866cd03ff9fefadef0bc8039d3617dc5526326..900453040e4a511e6a68468173cff94b5794fa9b 100644 (file)
--- a/src/ld/parsers/archive_file.cpp
+++ b/src/ld/parsers/archive_file.cpp
@@ -1,6 +1,6 @@
 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
  *
 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
  *

- * Copyright (c) 2005-2009 Apple Inc. All rights reserved.
+ * Copyright (c) 2005-2011 Apple Inc. All rights reserved.

  *
  * @APPLE_LICENSE_HEADER_START@
  *
  *
  * @APPLE_LICENSE_HEADER_START@
  *


@@ -31,8 +31,9 @@
 
 #include <vector>
 #include <set>
 
 #include <vector>
 #include <set>

+#include <map>

 #include <algorithm>
 #include <algorithm>

-#include <ext/hash_map>
+#include <unordered_map>

 
 #include "MachOFileAbstraction.hpp"
 #include "Architectures.hpp"
 
 #include "MachOFileAbstraction.hpp"
 #include "Architectures.hpp"


@@ -61,7 +62,7 @@ public:
                                                                                                                return File<A>::validFile(fileContent, fileLength, opts); }
        static File<A>*                                                                 parse(const uint8_t* fileContent, uint64_t fileLength, 
                                                                                                                        const char* path, time_t mTime, 
                                                                                                                return File<A>::validFile(fileContent, fileLength, opts); }
        static File<A>*                                                                 parse(const uint8_t* fileContent, uint64_t fileLength, 
                                                                                                                        const char* path, time_t mTime, 

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

                                                                                                                         return new File<A>(fileContent, fileLength, path, mTime,
                                                                                                                                                        ordinal, opts);
                                                                                                                }
                                                                                                                         return new File<A>(fileContent, fileLength, path, mTime,
                                                                                                                                                        ordinal, opts);
                                                                                                                }


@@ -69,14 +70,14 @@ public:
 };
 
 template <typename A>
 };
 
 template <typename A>

-class File : public ld::File
+class File : public ld::archive::File

 {
 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, 
 {
 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, 

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

        virtual                                                                                 ~File() {}
 
        // overrides of ld::File
        virtual                                                                                 ~File() {}
 
        // overrides of ld::File


@@ -84,6 +85,9 @@ public:
        virtual bool                                                                            justInTimeforEachAtom(const char* name, ld::File::AtomHandler&) const;
        virtual uint32_t                                                                        subFileCount() const  { return _archiveFilelength/sizeof(ar_hdr); }
        
        virtual bool                                                                            justInTimeforEachAtom(const char* name, ld::File::AtomHandler&) const;
        virtual uint32_t                                                                        subFileCount() const  { return _archiveFilelength/sizeof(ar_hdr); }
        

+       // overrides of ld::archive::File
+       virtual bool                                                                            justInTimeDataOnlyforEachAtom(const char* name, ld::File::AtomHandler& handler) const;
+

 private:
        static bool                                                                             validMachOFile(const uint8_t* fileContent, uint64_t fileLength, 
                                                                                                                                        const mach_o::relocatable::ParserOptions& opts);
 private:
        static bool                                                                             validMachOFile(const uint8_t* fileContent, uint64_t fileLength, 
                                                                                                                                        const mach_o::relocatable::ParserOptions& opts);


@@ -91,11 +95,10 @@ private:
                                                                                                                                        const mach_o::relocatable::ParserOptions& opts);
        static cpu_type_t                                                               architecture();
 
                                                                                                                                        const mach_o::relocatable::ParserOptions& opts);
        static cpu_type_t                                                               architecture();
 

-

        class Entry : ar_hdr
        {
        public:
        class Entry : ar_hdr
        {
        public:

-               const char*                     name() const;
+               void                            getName(char *, int) const;

                time_t                          modificationTime() const;
                const uint8_t*          content() const;
                uint32_t                        contentSize() const;
                time_t                          modificationTime() const;
                const uint8_t*          content() const;
                uint32_t                        contentSize() const;


@@ -106,18 +109,18 @@ private:
 
        };
 
 
        };
 

-       class CStringEquals
-       {
-       public:
-               bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
-       };
-       typedef __gnu_cxx::hash_map<const char*, const struct ranlib*, __gnu_cxx::hash<const char*>, CStringEquals> NameToEntryMap;
+       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;
+
+       typedef std::unordered_map<const char*, const struct ranlib*, ld::CStringHash, ld::CStringEquals> NameToEntryMap;

 
        typedef typename A::P                                                   P;
        typedef typename A::P::E                                                E;
 
 
        typedef typename A::P                                                   P;
        typedef typename A::P::E                                                E;
 

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

        const struct ranlib*                                                    ranlibHashSearch(const char* name) const;
        const struct ranlib*                                                    ranlibHashSearch(const char* name) const;

-       ld::relocatable::File*                                                  makeObjectFileForMember(const Entry* member) const;
+       MemberState&                                                                    makeObjectFileForMember(const Entry* member) const;

        bool                                                                                    memberHasObjCCategories(const Entry* member) const;
        void                                                                                    dumpTableOfContents();
        void                                                                                    buildHashTable();
        bool                                                                                    memberHasObjCCategories(const Entry* member) const;
        void                                                                                    dumpTableOfContents();
        void                                                                                    buildHashTable();


@@ -127,12 +130,12 @@ private:
        const struct ranlib*                                                    _tableOfContents;
        uint32_t                                                                                _tableOfContentCount;
        const char*                                                                             _tableOfContentStrings;
        const struct ranlib*                                                    _tableOfContents;
        uint32_t                                                                                _tableOfContentCount;
        const char*                                                                             _tableOfContentStrings;

-       mutable std::vector<ld::relocatable::File*>             _instantiatedFiles;
-       mutable std::set<const class Entry*>                    _instantiatedEntries;
+       mutable MemberToStateMap                                                _instantiatedEntries;

        NameToEntryMap                                                                  _hashTable;
        const bool                                                                              _forceLoadAll;
        const bool                                                                              _forceLoadObjC;
        const bool                                                                              _forceLoadThis;
        NameToEntryMap                                                                  _hashTable;
        const bool                                                                              _forceLoadAll;
        const bool                                                                              _forceLoadObjC;
        const bool                                                                              _forceLoadThis;

+       const bool                                                                              _objc2ABI;

        const bool                                                                              _verboseLoad;
        const bool                                                                              _logAllFiles;
        const mach_o::relocatable::ParserOptions                _objOpts;
        const bool                                                                              _verboseLoad;
        const bool                                                                              _logAllFiles;
        const mach_o::relocatable::ParserOptions                _objOpts;


@@ -154,23 +157,21 @@ unsigned int File<A>::Entry::getLongNameSpace() const
 }
 
 template <typename A>
 }
 
 template <typename A>

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

 {
        if ( this->hasLongName() ) {
                int len = this->getLongNameSpace();
 {
        if ( this->hasLongName() ) {
                int len = this->getLongNameSpace();

-               static char longName[256];
-               strncpy(longName, ((char*)this)+sizeof(ar_hdr), len);
-               longName[len] = '\0';
-               return longName;
+               assert(bufsz >= len+1);
+               strncpy(buf, ((char*)this)+sizeof(ar_hdr), len);
+               buf[len] = '\0';

        }
        else {
        }
        else {

-               static char shortName[20];
-               strncpy(shortName, this->ar_name, 16);
-               shortName[16] = '\0';
-               char* space = strchr(shortName, ' ');
+               assert(bufsz >= 16+1);
+               strncpy(buf, this->ar_name, 16);
+               buf[16] = '\0';
+               char* space = strchr(buf, ' ');

                if ( space != NULL )
                        *space = '\0';
                if ( space != NULL )
                        *space = '\0';

-               return shortName;

        }
 }
 
        }
 }
 


@@ -219,11 +220,10 @@ const class File<A>::Entry* File<A>::Entry::next() const
 }
 
 
 }
 
 

-template <> cpu_type_t File<ppc>::architecture()    { return CPU_TYPE_POWERPC; }
-template <> cpu_type_t File<ppc64>::architecture()  { return CPU_TYPE_POWERPC64; }

 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<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; }

 
 
 template <typename A>
 
 
 template <typename A>


@@ -251,7 +251,8 @@ bool File<A>::validFile(const uint8_t* fileContent, uint64_t fileLength, const m
        const Entry* const start = (Entry*)&fileContent[8];
        const Entry* const end = (Entry*)&fileContent[fileLength];
        for (const Entry* p=start; p < end; p = p->next()) {
        const Entry* const start = (Entry*)&fileContent[8];
        const Entry* const end = (Entry*)&fileContent[fileLength];
        for (const Entry* p=start; p < end; p = p->next()) {

-               const char* memberName = p->name();
+               char memberName[256];
+               p->getName(memberName, sizeof(memberName));

                // skip option table-of-content member
                if ( (p==start) && ((strcmp(memberName, SYMDEF_SORTED) == 0) || (strcmp(memberName, SYMDEF) == 0)) )
                        continue;
                // skip option table-of-content member
                if ( (p==start) && ((strcmp(memberName, SYMDEF_SORTED) == 0) || (strcmp(memberName, SYMDEF) == 0)) )
                        continue;


@@ -265,12 +266,12 @@ bool File<A>::validFile(const uint8_t* fileContent, uint64_t fileLength, const m
 
 template <typename A>
 File<A>::File(const uint8_t fileContent[], uint64_t fileLength, const char* pth, time_t modTime, 
 
 template <typename A>
 File<A>::File(const uint8_t fileContent[], uint64_t fileLength, const char* pth, time_t modTime, 

-                                       uint32_t ord, const ParserOptions& opts)
- : ld::File(strdup(pth), modTime, ord),
+                                       ld::File::Ordinal ord, const ParserOptions& opts)
+ : ld::archive::File(strdup(pth), modTime, ord),

        _archiveFileContent(fileContent), _archiveFilelength(fileLength), 
        _tableOfContents(NULL), _tableOfContentCount(0), _tableOfContentStrings(NULL), 
        _forceLoadAll(opts.forceLoadAll), _forceLoadObjC(opts.forceLoadObjC), 
        _archiveFileContent(fileContent), _archiveFilelength(fileLength), 
        _tableOfContents(NULL), _tableOfContentCount(0), _tableOfContentStrings(NULL), 
        _forceLoadAll(opts.forceLoadAll), _forceLoadObjC(opts.forceLoadObjC), 

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

        _logAllFiles(opts.logAllFiles), _objOpts(opts.objOpts)
 {
        if ( strncmp((const char*)fileContent, "!<arch>\n", 8) != 0 )
        _logAllFiles(opts.logAllFiles), _objOpts(opts.objOpts)
 {
        if ( strncmp((const char*)fileContent, "!<arch>\n", 8) != 0 )


@@ -278,7 +279,9 @@ File<A>::File(const uint8_t fileContent[], uint64_t fileLength, const char* pth,
 
        if ( !_forceLoadAll ) {
                const Entry* const firstMember = (Entry*)&_archiveFileContent[8];
 
        if ( !_forceLoadAll ) {
                const Entry* const firstMember = (Entry*)&_archiveFileContent[8];

-               if ( (strcmp(firstMember->name(), SYMDEF_SORTED) == 0) || (strcmp(firstMember->name(), SYMDEF) == 0) ) {
+               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];
                        const uint8_t* contents = firstMember->content();
                        uint32_t ranlibArrayLen = E::get32(*((uint32_t*)contents));
                        _tableOfContents = (const struct ranlib*)&contents[4];


@@ -297,16 +300,17 @@ File<A>::File(const uint8_t fileContent[], uint64_t fileLength, const char* pth,
 template <>
 bool File<x86>::memberHasObjCCategories(const Entry* member) const
 {
 template <>
 bool File<x86>::memberHasObjCCategories(const Entry* member) const
 {

-       // i386 uses ObjC1 ABI which has .objc_category* global symbols
-       return false;
+       if ( _objc2ABI ) {      
+               // i386 for iOS simulator uses ObjC2 which has no global symbol for categories
+               return mach_o::relocatable::hasObjC2Categories(member->content());
+       }
+       else {
+               // i386 uses ObjC1 ABI which has .objc_category* global symbols
+    // <rdar://problem/11342022> strip -S on i386 pulls out .objc_category_name symbols from static frameworks
+               return mach_o::relocatable::hasObjC1Categories(member->content());
+       }

 }
 
 }
 

-template <>
-bool File<ppc>::memberHasObjCCategories(const Entry* member) const
-{
-       // ppc uses ObjC1 ABI which has .objc_category* global symbols
-       return false;
-}

 
 
 template <typename A>
 
 
 template <typename A>


@@ -318,9 +322,39 @@ bool File<A>::memberHasObjCCategories(const Entry* member) const
 
 
 template <typename A>
 
 
 template <typename A>

-ld::relocatable::File* File<A>::makeObjectFileForMember(const Entry* member) const
+typename File<A>::MemberState& File<A>::makeObjectFileForMember(const Entry* member) const

 {
 {

-       const char* memberName = member->name();
+       uint32_t memberIndex = 0;
+       // in case member was instantiated earlier but not needed yet
+       typename MemberToStateMap::iterator pos = _instantiatedEntries.find(member);
+       if ( pos == _instantiatedEntries.end() ) {
+               // Have to find the index of this member
+               const Entry* start;
+               uint32_t index;
+               if (_instantiatedEntries.size() == 0) {
+                       start = (Entry*)&_archiveFileContent[8];
+                       index = 1;
+               } else {
+                       MemberState &lastKnown = _instantiatedEntries.rbegin()->second;
+                       start = lastKnown.entry->next();
+                       index = lastKnown.index+1;
+               }
+               for (const Entry* p=start; p <= member; p = p->next(), index++) {
+                       MemberState state = {NULL, p, false, false, index};
+                       _instantiatedEntries[p] = state;
+                       if (member == p) {
+                               memberIndex = index;
+                       }
+               }
+       } else {
+               MemberState& state = pos->second;
+               if (state.file)
+                       return state;
+               memberIndex = state.index;
+       }
+       assert(memberIndex != 0);
+       char memberName[256];
+       member->getName(memberName, sizeof(memberName));

        char memberPath[strlen(this->path()) + strlen(memberName)+4];
        strcpy(memberPath, this->path());
        strcat(memberPath, "(");
        char memberPath[strlen(this->path()) + strlen(memberName)+4];
        strcpy(memberPath, this->path());
        strcat(memberPath, "(");


@@ -334,20 +368,25 @@ ld::relocatable::File* File<A>::makeObjectFileForMember(const Entry* member) con
                if ( (member->content() + member->contentSize()) > (_archiveFileContent+_archiveFilelength) )
                        throwf("corrupt archive, member contents extends past end of file");                                                                            
                const char* mPath = strdup(memberPath);
                if ( (member->content() + member->contentSize()) > (_archiveFileContent+_archiveFilelength) )
                        throwf("corrupt archive, member contents extends past end of file");                                                                            
                const char* mPath = strdup(memberPath);

-               // offset the ordinals in this mach-o .o file, so that atoms layout in same order as in archive
-               uint32_t memberIndex = ((uint8_t*)member - _archiveFileContent)/sizeof(ar_hdr);

                // see if member is mach-o file
                // 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(), 
                                                                                                                                        mPath, member->modificationTime(), 
                ld::relocatable::File* result = mach_o::relocatable::parse(member->content(), member->contentSize(), 
                                                                                                                                        mPath, member->modificationTime(), 

-                                                                                                                                       this->ordinal() + memberIndex, _objOpts);
-               if ( result != NULL )
-                       return result;
+                                                                                                                                       ordinal, _objOpts);
+               if ( result != NULL ) {
+                       MemberState state = {result, member, false, false, memberIndex};
+                       _instantiatedEntries[member] = state;
+                       return _instantiatedEntries[member];
+               }

                // see if member is llvm bitcode file
                result = lto::parse(member->content(), member->contentSize(), 
                // see if member is llvm bitcode file
                result = lto::parse(member->content(), member->contentSize(), 

-                                                               mPath, member->modificationTime(), this->ordinal() + memberIndex, 
-                                                               _objOpts.architecture, _objOpts.subType, _logAllFiles);
-               if ( result != NULL )
-                       return result;
+                                                               mPath, member->modificationTime(), ordinal, 
+                                                               _objOpts.architecture, _objOpts.subType, _logAllFiles, _objOpts.verboseOptimizationHints);
+               if ( result != NULL ) {
+                       MemberState state = {result, member, false, false, memberIndex};
+                       _instantiatedEntries[member] = state;
+                       return _instantiatedEntries[member];
+               }

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


@@ -357,6 +396,25 @@ ld::relocatable::File* File<A>::makeObjectFileForMember(const Entry* member) con
 }
 
 
 }
 
 

+template <typename A>
+bool File<A>::loadMember(MemberState& state, ld::File::AtomHandler& handler, const char *format, ...) const
+{
+       bool didSomething = false;
+       if (!state.loaded) {
+               if ( _verboseLoad && !state.logged ) {
+                       va_list list;
+                       va_start(list, format);
+                       vprintf(format, list);
+                       va_end(list);
+                       state.logged = true;
+               }
+               state.loaded = true;
+               didSomething = state.file->forEachAtom(handler);
+       }
+       return didSomething;
+}
+
+

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


@@ -366,17 +424,12 @@ bool File<A>::forEachAtom(ld::File::AtomHandler& handler) const
                const Entry* const start = (Entry*)&_archiveFileContent[8];
                const Entry* const end = (Entry*)&_archiveFileContent[_archiveFilelength];
                for (const Entry* p=start; p < end; p = p->next()) {
                const Entry* const start = (Entry*)&_archiveFileContent[8];
                const Entry* const end = (Entry*)&_archiveFileContent[_archiveFilelength];
                for (const Entry* p=start; p < end; p = p->next()) {

-                       const char* memberName = p->name();
+                       char memberName[256];
+                       p->getName(memberName, sizeof(memberName));

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

-                       if ( _verboseLoad ) {
-                               if ( _forceLoadThis )
-                                       printf("-force_load forced load of %s(%s)\n", this->path(), memberName);
-                               else
-                                       printf("-all_load forced load of %s(%s)\n", this->path(), memberName);
-                       }
-                       ld::relocatable::File* file = this->makeObjectFileForMember(p);
-                       didSome |= file->forEachAtom(handler);
+                       MemberState& state = this->makeObjectFileForMember(p);
+                       didSome |= loadMember(state, handler, "%s forced load of %s(%s)\n", _forceLoadThis ? "-force_load" : "-all_load", this->path(), memberName);

                }
        }
        else if ( _forceLoadObjC ) {
                }
        }
        else if ( _forceLoadObjC ) {


@@ -384,32 +437,29 @@ bool File<A>::forEachAtom(ld::File::AtomHandler& handler) const
                for(typename NameToEntryMap::const_iterator it = _hashTable.begin(); it != _hashTable.end(); ++it) {
                        if ( (strncmp(it->first, ".objc_c", 7) == 0) || (strncmp(it->first, "_OBJC_CLASS_$_", 14) == 0) ) {
                                const Entry* member = (Entry*)&_archiveFileContent[E::get32(it->second->ran_off)];
                for(typename NameToEntryMap::const_iterator it = _hashTable.begin(); it != _hashTable.end(); ++it) {
                        if ( (strncmp(it->first, ".objc_c", 7) == 0) || (strncmp(it->first, "_OBJC_CLASS_$_", 14) == 0) ) {
                                const Entry* member = (Entry*)&_archiveFileContent[E::get32(it->second->ran_off)];

-                               if ( _instantiatedEntries.count(member) == 0 ) {
-                                       if ( _verboseLoad )
-                                               printf("-ObjC forced load of %s(%s)\n", this->path(), member->name());
-                                       // only return these atoms once
-                                       _instantiatedEntries.insert(member);
-                                       ld::relocatable::File* file = this->makeObjectFileForMember(member);
-                                       didSome |= file->forEachAtom(handler);
-                                       _instantiatedFiles.push_back(file);
-                               }
+                               MemberState& state = this->makeObjectFileForMember(member);
+                               char memberName[256];
+                               member->getName(memberName, sizeof(memberName));
+                               didSome |= loadMember(state, handler, "-ObjC forced load of %s(%s)\n", this->path(), memberName);

                        }
                }
                        }
                }

-               // ObjC2 has no symbols in .o files with categories, but not classes, look deeper for those
+               // 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()) {
                const Entry* const start = (Entry*)&_archiveFileContent[8];
                const Entry* const end = (Entry*)&_archiveFileContent[_archiveFilelength];
                for (const Entry* member=start; member < end; member = member->next()) {

-                       // only look at files not already instantiated
-                       if ( _instantiatedEntries.count(member) == 0 ) {
-                               //fprintf(stderr, "checking member %s\n", member->name());
+                       char mname[256];
+                       member->getName(mname, sizeof(mname));
+                       // skip table-of-content member
+                       if ( (member==start) && ((strcmp(mname, SYMDEF_SORTED) == 0) || (strcmp(mname, SYMDEF) == 0)) )
+                               continue;
+                       MemberState& state = this->makeObjectFileForMember(member);
+                       // only look at files not already loaded
+                       if ( ! state.loaded ) {

                                if ( this->memberHasObjCCategories(member) ) {
                                if ( this->memberHasObjCCategories(member) ) {

-                                       if ( _verboseLoad )
-                                               printf("-ObjC forced load of %s(%s)\n", this->path(), member->name());
-                                       // only return these atoms once
-                                       _instantiatedEntries.insert(member);
-                                       ld::relocatable::File* file = this->makeObjectFileForMember(member);
-                                       didSome |= file->forEachAtom(handler);
-                                       _instantiatedFiles.push_back(file);
+                                       MemberState& state = this->makeObjectFileForMember(member);
+                                       char memberName[256];
+                                       member->getName(memberName, sizeof(memberName));
+                                       didSome |= loadMember(state, handler, "-ObjC forced load of %s(%s)\n", this->path(), memberName);

                                }
                        }
                }
                                }
                        }
                }


@@ -428,14 +478,55 @@ bool File<A>::justInTimeforEachAtom(const char* name, ld::File::AtomHandler& han
        const struct ranlib* result = ranlibHashSearch(name);
        if ( result != NULL ) {
                const Entry* member = (Entry*)&_archiveFileContent[E::get32(result->ran_off)];
        const struct ranlib* result = ranlibHashSearch(name);
        if ( result != NULL ) {
                const Entry* member = (Entry*)&_archiveFileContent[E::get32(result->ran_off)];

+               MemberState& state = this->makeObjectFileForMember(member);
+               char memberName[256];
+               member->getName(memberName, sizeof(memberName));
+               return loadMember(state, handler, "%s forced load of %s(%s)\n", name, this->path(), memberName);
+       }
+       //fprintf(stderr, "%s NOT found in archive %s\n", name, this->path());
+       return false;
+}
+
+class CheckIsDataSymbolHandler : public ld::File::AtomHandler
+{
+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 )
+                                                               _isData = true;
+                                               }
+                                       }
+       virtual void    doFile(const class ld::File&) {}
+       bool                    symbolIsDataDefinition() { return _isData; }
+
+private:
+       const char*             _name;
+       bool                    _isData;
+
+};
+
+template <typename A>
+bool File<A>::justInTimeDataOnlyforEachAtom(const char* name, ld::File::AtomHandler& handler) const
+{
+       // in force load case, all members already loaded
+       if ( _forceLoadAll || _forceLoadThis ) 
+               return false;
+       
+       // do a hash search of table of contents looking for requested symbol
+       const struct ranlib* result = ranlibHashSearch(name);
+       if ( result != NULL ) {
+               const Entry* member = (Entry*)&_archiveFileContent[E::get32(result->ran_off)];
+               MemberState& state = this->makeObjectFileForMember(member);

                // only call handler for each member once
                // only call handler for each member once

-               if ( _instantiatedEntries.count(member) == 0 ) {
-                       _instantiatedEntries.insert(member);
-                       if ( _verboseLoad ) 
-                               printf("%s forced load of %s(%s)\n", name, this->path(), member->name());
-                       ld::relocatable::File* file = this->makeObjectFileForMember(member);
-                       _instantiatedFiles.push_back(file);
-                       return file->forEachAtom(handler);
+               if ( ! state.loaded ) {
+                       CheckIsDataSymbolHandler checker(name);
+                       state.file->forEachAtom(checker);
+                       if ( checker.symbolIsDataDefinition() ) {
+                               char memberName[256];
+                               member->getName(memberName, sizeof(memberName));
+                               return loadMember(state, handler, "%s forced load of %s(%s)\n", name, this->path(), memberName);
+                       }

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


@@ -487,30 +578,34 @@ void File<A>::dumpTableOfContents()
 //
 // main function used by linker to instantiate archive files
 //
 //
 // main function used by linker to instantiate archive files
 //

-ld::File* parse(const uint8_t* fileContent, uint64_t fileLength, 
-                               const char* path, time_t modTime, uint32_t ordinal, const ParserOptions& opts)
+ld::archive::File* parse(const uint8_t* fileContent, uint64_t fileLength, 
+                               const char* path, time_t modTime, ld::File::Ordinal ordinal, const ParserOptions& opts)

 {
        switch ( opts.objOpts.architecture ) {
 {
        switch ( opts.objOpts.architecture ) {

+#if SUPPORT_ARCH_x86_64

                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);
                        break;
                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);
                        break;

+#endif
+#if SUPPORT_ARCH_i386

                case CPU_TYPE_I386:
                        if ( archive::Parser<x86>::validFile(fileContent, fileLength, opts.objOpts) )
                                return archive::Parser<x86>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
                        break;
                case CPU_TYPE_I386:
                        if ( archive::Parser<x86>::validFile(fileContent, fileLength, opts.objOpts) )
                                return archive::Parser<x86>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
                        break;

+#endif
+#if SUPPORT_ARCH_arm_any

                case CPU_TYPE_ARM:
                        if ( archive::Parser<arm>::validFile(fileContent, fileLength, opts.objOpts) )
                                return archive::Parser<arm>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
                        break;
                case CPU_TYPE_ARM:
                        if ( archive::Parser<arm>::validFile(fileContent, fileLength, opts.objOpts) )
                                return archive::Parser<arm>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
                        break;

-               case CPU_TYPE_POWERPC:
-                       if ( archive::Parser<ppc>::validFile(fileContent, fileLength, opts.objOpts) )
-                               return archive::Parser<ppc>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
-                       break;
-               case CPU_TYPE_POWERPC64:
-                       if ( archive::Parser<ppc64>::validFile(fileContent, fileLength, opts.objOpts) )
-                               return archive::Parser<ppc64>::parse(fileContent, fileLength, path, modTime, ordinal, opts);
+#endif
+#if SUPPORT_ARCH_arm64
+               case CPU_TYPE_ARM64:
+                       if ( archive::Parser<arm64>::validFile(fileContent, fileLength, opts.objOpts) )
+                               return archive::Parser<arm64>::parse(fileContent, fileLength, path, modTime, ordinal, opts);

                        break;
                        break;

+#endif

        }
        return NULL;
 }
        }
        return NULL;
 }