ld64-21.tar.gz

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

/*
 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>

#include <string>
#include <set>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <ext/hash_map>

#include "Options.h"

#include "ObjectFile.h"
#include "ObjectFileMachO-all.h"

#include "ExecutableFile.h"
#include "ExecutableFileMachO-all.h"

#include "SectCreate.h"

#if 0
static void dumpAtom(ObjectFile::Atom* atom)
{
        //printf("atom:    %p\n", atom);
        
        // name
        printf("name:    %s\n",  atom->getDisplayName());
        
        // scope
        switch ( atom->getScope() ) {
                case ObjectFile::Atom::scopeTranslationUnit:
                        printf("scope:   translation unit\n");
                        break;
                case ObjectFile::Atom::scopeLinkageUnit:
                        printf("scope:   linkage unit\n");
                        break;
                case ObjectFile::Atom::scopeGlobal:
                        printf("scope:   global\n");
                        break;
                default:
                        printf("scope:   unknown\n");
        }
        
        // segment and section
        printf("section: %s,%s\n", atom->getSegment().getName(), atom->getSectionName());

        // attributes
        printf("attrs:   ");
        if ( atom->isTentativekDefinition() )
                printf("tentative ");
        else if ( atom->isWeakDefinition() )
                printf("weak ");
        if ( atom->isCoalesableByName() )
                printf("coalesce-by-name ");
        if ( atom->isCoalesableByValue() )
                printf("coalesce-by-value ");
        if ( atom->dontDeadStrip() )
                printf("dont-dead-strip ");
        if ( atom->isZeroFill() )
                printf("zero-fill ");
        printf("\n");
        
        // size
        printf("size:    0x%012llX\n", atom->getSize());
        
        // content
        uint8_t content[atom->getSize()];
        atom->copyRawContent(content);
        printf("content: ");
        if ( strcmp(atom->getSectionName(), "__cstring") == 0 ) {
                printf("\"%s\"", content);
        }
        else {
                for (unsigned int i=0; i < sizeof(content); ++i)
                        printf("%02X ", content[i]);
        }
        printf("\n");
        
        // references
        std::vector<ObjectFile::Reference*>&  references = atom->getReferences();
        const int refCount = references.size();
        printf("references: (%u)\n", refCount);
        for (int i=0; i < refCount; ++i) {
                ObjectFile::Reference* ref = references[i];
                printf("   %s\n", ref->getDescription());
        }
        
        // attributes
        
}

#endif

class CStringComparor
{
public:
        bool operator()(const char* left, const char* right) const { return (strcmp(left, right) < 0); }
};

class CStringEquals
{
public:
        bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
};

class Section : public ObjectFile::Section
{
public:
        static Section* find(const char* sectionName, const char* segmentName, bool zeroFill);
        static void             assignIndexes();

private:
                                        Section(const char* sectionName, const char* segmentName, bool zeroFill);

        struct Sorter {
                static int      segmentOrdinal(const char* segName);
                bool operator()(Section* left, Section* right);
        };

        typedef __gnu_cxx::hash_map<const char*, class Section*, __gnu_cxx::hash<const char*>, CStringEquals> NameToSection;
        //typedef std::map<const char*, class Section*, CStringComparor> NameToSection;

        const char*             fSectionName;
        const char*             fSegmentName;
        bool                    fZeroFill;

        static NameToSection                    fgMapping;
        static std::vector<Section*>    fgSections;
};

Section::NameToSection  Section::fgMapping;
std::vector<Section*>   Section::fgSections;

Section::Section(const char* sectionName, const char* segmentName, bool zeroFill)
 : fSectionName(sectionName), fSegmentName(segmentName), fZeroFill(zeroFill)
{
        //fprintf(stderr, "new Section(%s, %s)\n", sectionName, segmentName);
}

Section* Section::find(const char* sectionName, const char* segmentName, bool zeroFill)
{
#if 0
        std::pair<NameToSection::iterator, NameToSection::iterator> range = fgMapping.equal_range(sectionName);
        for (NameToSection::iterator it=range.first; it != range.second; it++) {
                if ( strcmp(it->second->fSegmentName, segmentName) == 0 )
                        return it->second;
        }
#endif
        NameToSection::iterator pos = fgMapping.find(sectionName);
        if ( pos != fgMapping.end() ) {
                if ( strcmp(pos->second->fSegmentName, segmentName) == 0 )
                        return pos->second;
                // otherwise same section name is used in different segments, look slow way
                for (std::vector<Section*>::iterator it=fgSections.begin(); it != fgSections.end(); it++) {
                        if ( (strcmp((*it)->fSectionName, sectionName) == 0) && (strcmp((*it)->fSegmentName, segmentName) == 0) )
                                return *it;
                }
        }
        
        // does not exist, so make a new one
        Section* sect = new Section(sectionName, segmentName, zeroFill);
        sect->fIndex = fgMapping.size();
        fgMapping[sectionName] = sect;
        fgSections.push_back(sect);
        return sect;
}

int Section::Sorter::segmentOrdinal(const char* segName)
{
        if ( strcmp(segName, "__PAGEZERO") == 0 )
                return 1;
        if ( strcmp(segName, "__TEXT") == 0 )
                return 2;
        if ( strcmp(segName, "__DATA") == 0 )
                return 3;
        if ( strcmp(segName, "__OBJC") == 0 )
                return 4;
        if ( strcmp(segName, "__LINKEDIT") == 0 )
                return INT_MAX; // linkedit segment should always sort last
        else 
                return 5;
}


bool Section::Sorter::operator()(Section* left, Section* right)
{
        // Segment is primary sort key
        const char* leftSegName = left->fSegmentName;
        const char* rightSegName = right->fSegmentName;
        int segNameCmp = strcmp(leftSegName, rightSegName);
        if ( segNameCmp != 0 )
        {
                int leftSegOrdinal = segmentOrdinal(leftSegName);
                int rightSegOrdinal = segmentOrdinal(rightSegName);
                if ( leftSegOrdinal < rightSegOrdinal )
                        return true;
                if ( leftSegOrdinal == rightSegOrdinal )
                        return segNameCmp < 0;
                return false;
        }

        // zerofill section sort to the end
        if ( !left->fZeroFill && right->fZeroFill )
                return true;
        if ( left->fZeroFill && !right->fZeroFill )
                return false;

        // section discovery order is last sort key
        return left->fIndex < right->fIndex;
}

void Section::assignIndexes()
{
        //printf("unsorted:\n");
        //for (std::vector<Section*>::iterator it=fgSections.begin(); it != fgSections.end(); it++) {
        //      printf("section: name=%s, segment: name=%s, discovery order=%d\n", (*it)->fSectionName, (*it)->fSegmentName, (*it)->fIndex);
        //}

        // sort it
        std::sort(fgSections.begin(), fgSections.end(), Section::Sorter());
        
        // assign correct section ordering to each Section object
        unsigned int newOrder = 1;
        for (std::vector<Section*>::iterator it=fgSections.begin(); it != fgSections.end(); it++) 
                (*it)->fIndex = newOrder++;

        //printf("sorted:\n");
        //for (std::vector<Section*>::iterator it=fgSections.begin(); it != fgSections.end(); it++) {
        //      printf("section: name=%s\n", (*it)->fSectionName);
        //}
}

class Linker {
public:
                                                Linker(int argc, const char* argv[]);

        void                            createReaders();
        void                            createWriter();
        void                            addInputFile(ObjectFile::Reader* reader);
        void                            setOutputFile(ExecutableFile::Writer* writer);
        void                            link();
        
        
private:
        ObjectFile::Reader*     createReader(const Options::FileInfo&);
        void                            addAtom(ObjectFile::Atom& atom);
        void                            addAtoms(std::vector<class ObjectFile::Atom*>& atoms);
        void                            buildAtomList();
        void                            loadUndefines();
        void                            addWeakAtomOverrides();
        void                            resolveReferences();
        void                            deadStrip();
        void                            sortAtoms();
        void                            tweakLayout();
        void                            writeOutput();
        
        void                            resolve(ObjectFile::Reference* reference);
        void                            addJustInTimeAtoms(const char* name);
        
        void                            addDylib(ObjectFile::Reader* reader, const Options::FileInfo& info);
        void                            addIndirectLibraries(ObjectFile::Reader* reader);
        bool                            haveIndirectLibrary(const char* path, ObjectFile::Reader* reader);
        bool                            haveDirectLibrary(const char* path);

        struct SegmentAndItsAtoms
        {
                class Segment*                                          fSegment;
                uint64_t                                                        fSegmentSize;
                uint64_t                                                        fSegmentBaseAddress;
                std::vector<class ObjectFile::Atom*>    fAtoms;
        };
        
        
        class SymbolTable
        {
        public:
                                                        SymbolTable(Linker&);
                void                            require(const char* name);
                bool                            add(ObjectFile::Atom& atom);
                ObjectFile::Atom*       find(const char* name);
                unsigned int            getRequireCount() { return fRequireCount; }
                void                            getNeededNames(bool andWeakDefintions, std::vector<const char*>& undefines);
        private:
                typedef std::map<const char*, ObjectFile::Atom*, CStringComparor> Mapper;
                Linker&                         fOwner;
                Mapper                          fTable;
                unsigned int            fRequireCount;
        };
        
        struct AtomSorter
        {
                bool operator()(ObjectFile::Atom* left, ObjectFile::Atom* right);
        };
        
        typedef std::map<const char*, uint32_t, CStringComparor> SectionOrder;
        
        struct IndirectLibrary {
                const char*                                                     path;
                uint64_t                                                        fileLen;
                ObjectFile::Reader*                                     reader;
                std::set<ObjectFile::Reader*>           parents;
                ObjectFile::Reader*                                     reExportParent;
        };
        
        Options                                                                                         fOptions;
        SymbolTable                                                                                     fGlobalSymbolTable;
        unsigned int                                                                            fWeakSymbolsAddedCount;
        std::vector<class ObjectFile::Reader*>                          fInputFiles;
        ExecutableFile::Writer*                                                         fOutputFile;
        std::vector<ExecutableFile::DyLibUsed>                          fDynamicLibraries;
        std::list<IndirectLibrary>                                                      fIndirectDynamicLibraries;
        std::vector<class ObjectFile::Atom*>                            fAllAtoms;
        std::vector< SegmentAndItsAtoms >                                       fAllAtomsBySegment;
        std::set<class ObjectFile::Atom*>                                       fDeadAtoms;
        SectionOrder                                                                            fSectionOrder;
        unsigned int                                                                            fNextSortOrder;
        bool                                                                                            fDirectLibrariesComplete;
};



Linker::Linker(int argc, const char* argv[])
 : fOptions(argc, argv), fGlobalSymbolTable(*this), fOutputFile(NULL), fNextSortOrder(1), fDirectLibrariesComplete(false)
{
}

void Linker::addInputFile(ObjectFile::Reader* reader)
{
        fInputFiles.push_back(reader);
}

void Linker::setOutputFile(ExecutableFile::Writer* writer)
{
        fOutputFile = writer;
}

void Linker::link()
{               
        this->buildAtomList();
        this->loadUndefines();
        this->resolveReferences();
        this->deadStrip();
        this->sortAtoms();
        this->tweakLayout();
        this->writeOutput();
}

inline void Linker::addAtom(ObjectFile::Atom& atom)
{
        // add to list of all atoms
        fAllAtoms.push_back(&atom);
        
        // add atom's references's names to symbol table as to-be-resolved-later
        std::vector<class ObjectFile::Reference*>& references = atom.getReferences();
        for (std::vector<ObjectFile::Reference*>::iterator it=references.begin(); it != references.end(); it++) {
                ObjectFile::Reference* reference = *it;
                if ( reference->isUnbound() ) {
                        fGlobalSymbolTable.require(reference->getTargetName());
                }
        }
        
        // if in global namespace, add atom itself to symbol table
        ObjectFile::Atom::Scope scope = atom.getScope();
        const char* name = atom.getName();
        if ( (scope != ObjectFile::Atom::scopeTranslationUnit) && (name != NULL) ) {
                fGlobalSymbolTable.add(atom);
                
                // update scope based on export list (possible that globals are downgraded to private_extern)
                if ( (scope == ObjectFile::Atom::scopeGlobal) && fOptions.hasExportRestrictList() ) {
                        bool doExport = fOptions.shouldExport(name);
                        if ( !doExport ) {
                                atom.setScope(ObjectFile::Atom::scopeLinkageUnit);
                        }
                }
        }
                
        // record section orders so output file can have same order
        atom.setSection(Section::find(atom.getSectionName(), atom.getSegment().getName(), atom.isZeroFill()));
        
        // assign order in which this atom was originally seen
        if ( atom.getSortOrder() == 0 )
                fNextSortOrder = atom.setSortOrder(fNextSortOrder);
}

inline void Linker::addAtoms(std::vector<class ObjectFile::Atom*>& atoms)
{
        for (std::vector<ObjectFile::Atom*>::iterator it=atoms.begin(); it != atoms.end(); it++) {
                this->addAtom(**it);
        }
}

void Linker::buildAtomList()
{
        // add initial undefines from -u option
        std::vector<const char*>& initialUndefines = fOptions.initialUndefines();
        for (std::vector<const char*>::iterator it=initialUndefines.begin(); it != initialUndefines.end(); it++) {
                fGlobalSymbolTable.require(*it);
        }
        
        // writer can contribute atoms 
        this->addAtoms(fOutputFile->getAtoms());
        
        // each reader contributes atoms
        const int readerCount = fInputFiles.size();
        for (int i=0; i < readerCount; ++i) {
                this->addAtoms(fInputFiles[i]->getAtoms());
        }
        
        // extra command line section always at end
        std::vector<Options::ExtraSection>& extraSections = fOptions.extraSections();
        for( std::vector<Options::ExtraSection>::iterator it=extraSections.begin(); it != extraSections.end(); ++it) {
                this->addAtoms(SectCreate::MakeReader(it->segmentName, it->sectionName, it->path, it->data, it->dataLen)->getAtoms());
        }
}

void Linker::loadUndefines()
{
        // keep looping until no more undefines were added in last loop
        unsigned int undefineCount = 0xFFFFFFFF;
        while ( undefineCount != fGlobalSymbolTable.getRequireCount() ) {
                undefineCount = fGlobalSymbolTable.getRequireCount();
                std::vector<const char*> undefineNames;
                fGlobalSymbolTable.getNeededNames(true, undefineNames);
                const int undefineCount = undefineNames.size();
                for (int i=0; i < undefineCount; ++i) {
                        const char* name = undefineNames[i];
                        ObjectFile::Atom* possibleAtom = fGlobalSymbolTable.find(name);
                        if ( (possibleAtom == NULL) || (possibleAtom->isWeakDefinition() && (fOptions.outputKind() != Options::kObjectFile)) )
                                this->addJustInTimeAtoms(name);
                }
        }
        
        if ( fOptions.outputKind() != Options::kObjectFile ) {
                // error out on any remaining undefines
                bool doPrint = true;
                bool doError = true;
                switch ( fOptions.undefinedTreatment() ) {
                        case Options::kUndefinedError:
                                break;
                        case Options::kUndefinedDynamicLookup:
                                doError = false;
                                break;
                        case Options::kUndefinedWarning:
                                doError = false;
                                break;
                        case Options::kUndefinedSuppress:
                                doError = false;
                                doPrint = false;
                                break;
                }
                std::vector<const char*> unresolvableUndefines;
                fGlobalSymbolTable.getNeededNames(false, unresolvableUndefines);
                const int unresolvableCount = unresolvableUndefines.size();
                if ( unresolvableCount != 0 ) {
                        if ( doPrint ) {
                                fprintf(stderr, "can't resolve symbols:\n");
                                for (int i=0; i < unresolvableCount; ++i) {
                                        const char* name = unresolvableUndefines[i];
                                        const unsigned int nameLen = strlen(name);
                                        fprintf(stderr, "  %s, referenced from:\n", name);
                                        char stubName[nameLen+6];
                                        strcpy(stubName, name);
                                        strcat(stubName, "$stub");
                                        char nonLazyName[nameLen+16];
                                        strcpy(nonLazyName, name);
                                        strcat(nonLazyName, "$non_lazy_ptr");
                                        ObjectFile::Atom* lastStubAtomWithUnresolved = NULL;
                                        ObjectFile::Atom* lastNonLazyAtomWithUnresolved = NULL;
                                        for (std::vector<ObjectFile::Atom*>::iterator it=fAllAtoms.begin(); it != fAllAtoms.end(); it++) {
                                                ObjectFile::Atom* atom = *it;
                                                std::vector<class ObjectFile::Reference*>& references = atom->getReferences();
                                                for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); rit++) {
                                                        ObjectFile::Reference* reference = *rit;
                                                        if ( reference->isUnbound() ) {
                                                                if ( (atom != lastStubAtomWithUnresolved) && (strcmp(reference->getTargetName(), stubName) == 0) ) {
                                                                        const char* path = atom->getFile()->getPath();
                                                                        const char* shortPath = strrchr(path, '/');
                                                                        if ( shortPath == NULL )
                                                                                shortPath = path;
                                                                        else
                                                                                shortPath = &shortPath[1];
                                                                        fprintf(stderr, "      %s in %s\n", atom->getDisplayName(), shortPath);
                                                                        lastStubAtomWithUnresolved = atom;
                                                                }
                                                                else if ( (atom != lastNonLazyAtomWithUnresolved) && (strcmp(reference->getTargetName(), nonLazyName) == 0) ) {
                                                                        const char* path = atom->getFile()->getPath();
                                                                        const char* shortPath = strrchr(path, '/');
                                                                        if ( shortPath == NULL )
                                                                                shortPath = path;
                                                                        else
                                                                                shortPath = &shortPath[1];
                                                                        fprintf(stderr, "      %s in %s\n", atom->getDisplayName(), shortPath);
                                                                        lastNonLazyAtomWithUnresolved = atom;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        if ( doError )
                                throw "symbol(s) not found";
                }
                
                // now verify that -init routine exists
                if ( fOptions.initFunctionName() != NULL ) {
                        if ( fGlobalSymbolTable.find(fOptions.initFunctionName()) == NULL )
                                throwf("symbol %s not found for -init", fOptions.initFunctionName());
                }
        }
}



void Linker::addJustInTimeAtoms(const char* name)
{
        // give writer a crack at it
        ObjectFile::Atom* atom = fOutputFile->getUndefinedProxyAtom(name);
        if ( atom != NULL ) {
                this->addAtom(*atom);
        }
        else {
                // give direct readers a chance
                const int readerCount = fInputFiles.size();
                for (int i=0; i < readerCount; ++i) {
                        // if this reader is a static archive that has the symbol we need, pull in all atoms in that module
                        // if this reader is a dylib that exports the symbol we need, have it synthesize an atom for us.
                        std::vector<class ObjectFile::Atom*>* atoms = fInputFiles[i]->getJustInTimeAtomsFor(name);
                        if ( atoms != NULL ) {
                                this->addAtoms(*atoms);
                                delete atoms;
                                return;  // found a definition, no need to search anymore
                                //fprintf(stderr, "addJustInTimeAtoms(%s) => found in file #%d\n", name, i);
                        }
                }
                
                // give indirect readers a chance
                for (std::list<IndirectLibrary>::iterator it=fIndirectDynamicLibraries.begin(); it != fIndirectDynamicLibraries.end(); it++) {
                        ObjectFile::Reader* reader = it->reader;
                        if ( reader != NULL ) {
                                std::vector<class ObjectFile::Atom*>* atoms = reader->getJustInTimeAtomsFor(name);
                                if ( atoms != NULL ) {
                                        this->addAtoms(*atoms);
                                        delete atoms;
                                        break;
                                        //fprintf(stderr, "addJustInTimeAtoms(%s) => found in file #%d\n", name, i);
                                }
                        }
                }
        }
}

void Linker::resolve(ObjectFile::Reference* reference)
{
        ObjectFile::Atom* target = NULL;
        const char* targetName = reference->getTargetName();
        const int targetNameLen = strlen(targetName);
        if ( (targetNameLen > 5) && (strcmp(&targetName[targetNameLen-5], "$stub") == 0) ) {
                // when looking up "_foo$stub", first look for "_foo"
                char nonStubTarget[targetNameLen+1];
                strcpy(nonStubTarget, targetName);
                nonStubTarget[targetNameLen-5] = '\0';
                // unless interposing and the symbol is exported 
                if ( !fOptions.interposable() || !fOptions.shouldExport(nonStubTarget) ) {
                        target = fGlobalSymbolTable.find(nonStubTarget);        
                        // also need indirection to all exported weak symbols for C++ support
                        if ( (target != NULL) && !target->isImportProxy() && (!target->isWeakDefinition() || (target->getScope() != ObjectFile::Atom::scopeGlobal)) ) {
                                reference->setTarget(*target);
                                // mark stub as no longer being needed
                                ObjectFile::Atom* stub = fGlobalSymbolTable.find(targetName);
                                if ( stub != NULL ) {
                                        char lazySymbol[targetNameLen+8];
                                        strcpy(lazySymbol, nonStubTarget);
                                        strcat(lazySymbol, "$lazy_ptr");
                                        ObjectFile::Atom* lazyPtr = fGlobalSymbolTable.find(lazySymbol);
                                        fDeadAtoms.insert(stub);
                                        if ( lazyPtr != NULL )
                                                fDeadAtoms.insert(lazyPtr);
                                }
                                return;
                        }
                }
        }
        
        // look in global symbol table
        target = fGlobalSymbolTable.find(targetName);
        if ( target == NULL ) {
                fprintf(stderr, "can't resolve: %s\n", targetName);
        }
        reference->setTarget(*target);
        
        // handle weak-imports
        if ( target->isImportProxy() ) {
                bool mismatch = false;
                if ( reference->isWeakReference() ) {
                        switch(target->getImportWeakness()) {
                                case ObjectFile::Atom::kWeakUnset:
                                        target->setImportWeakness(true);
                    break;      
                                case ObjectFile::Atom::kWeakImport:
                                        break;
                                case ObjectFile::Atom::kNonWeakImport:
                                        mismatch = true;
                                        break;
                        }
                }
                else {
                        switch(target->getImportWeakness()) {
                                case ObjectFile::Atom::kWeakUnset:
                                        target->setImportWeakness(false);       
                    break;      
                                case ObjectFile::Atom::kWeakImport:
                                        mismatch = true;
                                        break;
                                case ObjectFile::Atom::kNonWeakImport:
                                        break;
                        }
                }
                if ( mismatch ) {
                        switch ( fOptions.weakReferenceMismatchTreatment() ) {
                                case Options::kWeakReferenceMismatchError:
                                        throwf("mismatching weak references for symbol: %s", target->getName());
                                case Options::kWeakReferenceMismatchWeak:
                                        target->setImportWeakness(true);
                                        break;
                                case Options::kWeakReferenceMismatchNonWeak:
                                        target->setImportWeakness(false);
                                        break;
                        }
                }
        }
        
        // handle references that have two (from and to) targets
        if ( reference->isUnbound() ) {
                const char* fromTargetName = reference->getFromTargetName();
                ObjectFile::Atom* fromTarget = fGlobalSymbolTable.find(fromTargetName);
                if ( target == NULL ) {
                        fprintf(stderr, "can't resolve: %s\n", fromTargetName);
                }
                reference->setFromTarget(*fromTarget);
        }
}


void Linker::resolveReferences()
{
        // note: the atom list may grow during this loop as libraries supply needed atoms
        for (unsigned int j=0; j < fAllAtoms.size(); ++j) {
                ObjectFile::Atom* atom = fAllAtoms[j];
                std::vector<class ObjectFile::Reference*>& references = atom->getReferences();
                for (std::vector<ObjectFile::Reference*>::iterator it=references.begin(); it != references.end(); it++) {
                        ObjectFile::Reference* reference = *it;
                        if ( reference->isUnbound() ) {
                                this->resolve(reference);
                        }
                }
        }
}

class InSet
{
public:
        InSet(std::set<ObjectFile::Atom*>& deadAtoms) : fDeadAtoms(deadAtoms) {}
        
        bool operator()(ObjectFile::Atom*& atom) const { 
                return ( fDeadAtoms.count(atom) != 0 );
        }
        
private:
        std::set<ObjectFile::Atom*>& fDeadAtoms;
};


void Linker::deadStrip()
{
        //printf("Stripping atoms:\n");
        //for (std::set<ObjectFile::Atom*>::iterator it=fDeadAtoms.begin(); it != fDeadAtoms.end(); it++) {
        //      printf("\t%s\n", (*it)->getDisplayName());
        //}

        // for now, just remove atoms weak atoms that have been overridden
        fAllAtoms.erase(std::remove_if(fAllAtoms.begin(), fAllAtoms.end(), InSet(fDeadAtoms)), fAllAtoms.end());
}



void Linker::sortAtoms()
{
        Section::assignIndexes();
        std::sort(fAllAtoms.begin(), fAllAtoms.end(), Linker::AtomSorter());
}



// make sure given addresses are within reach of branches, etc
void Linker::tweakLayout()
{
        


}


void Linker::writeOutput()
{
        // if main executable, find entry point atom
        ObjectFile::Atom* entryPoint;
        switch ( fOptions.outputKind() ) {
                case Options::kDynamicExecutable:
                case Options::kStaticExecutable:
                case Options::kDyld:
                        entryPoint = fGlobalSymbolTable.find(fOptions.entryName());
                        if ( entryPoint == NULL ) {
                                throwf("could not find entry point: %s", fOptions.entryName());
                        }
                        break;
                case Options::kDynamicLibrary:
                        if ( fOptions.initFunctionName() != NULL ) {
                                entryPoint = fGlobalSymbolTable.find(fOptions.initFunctionName());
                                if ( entryPoint == NULL ) {
                                        throwf("could not find -init function: %s", fOptions.initFunctionName());
                                }
                        }
                        break;
                default:
                        entryPoint = NULL;
        }
        
        // tell writer about each segment's atoms
        fOutputFile->write(fAllAtoms, entryPoint);
}




ObjectFile::Reader* Linker::createReader(const Options::FileInfo& info)
{
        // map in whole file
        uint64_t len = info.fileLen;
        int fd = ::open(info.path, O_RDONLY, 0);
        if ( fd == -1 )
                throw "can't open file";
        if ( info.fileLen < 20 )
                throw "file too small";
        char* p = (char*)::mmap(NULL, info.fileLen, PROT_READ, MAP_FILE, fd, 0);
        if ( p == (char*)(-1) )
                throw "can't map file";
        ::close(fd);
        
        // if fat file, skip to architecture we want
        const mach_header* mh = (mach_header*)p;
        if ( mh->magic == OSSwapBigToHostInt32(FAT_MAGIC) ) {
                // Fat header is always big-endian
                const struct fat_header* fh = (struct fat_header*)p;
                const struct fat_arch* archs = (struct fat_arch*)(p + sizeof(struct fat_header));
                for (unsigned long i=0; i < OSSwapBigToHostInt32(fh->nfat_arch); ++i) {
                        if ( OSSwapBigToHostInt32(archs[i].cputype) == (uint32_t)fOptions.architecture() ) {
                                mh = (struct mach_header*)((char*)p + OSSwapBigToHostInt32(archs[i].offset));
                                len = OSSwapBigToHostInt32(archs[i].size);
                                break;
                        }
                }
        }
        
        if ( mh->magic == OSSwapBigToHostInt32(FAT_MAGIC) ) {
                const char* archName = "unknown";
                switch (fOptions.architecture()) {
                        case CPU_TYPE_POWERPC:
                                archName = "ppc";
                                break;
                        case CPU_TYPE_POWERPC64:
                                archName = "ppc64";
                                break;
                        case CPU_TYPE_I386:
                                archName = "i386";
                                break;
                }
                throwf("missing required architecture %s in fat file", archName);
        }
        
        // pull out cpu-type and file-type in endian-safe way
        cpu_type_t cpuType = 0;
        uint32_t fileType = 0;
        if ( mh->magic == MH_MAGIC ) {
                fileType = mh->filetype;
                cpuType = mh->cputype;
        }
        else if ( mh->magic == OSSwapInt32(MH_MAGIC) ) {
                fileType = OSSwapInt32(mh->filetype);
                cpuType = OSSwapInt32(mh->cputype);
        }
        else if ( mh->magic == MH_MAGIC_64 ) {
                fileType = ((mach_header_64*)mh)->filetype;
                cpuType = ((mach_header_64*)mh)->cputype;
        }
        else if ( mh->magic == OSSwapInt32(MH_MAGIC_64) ) {
                fileType = OSSwapInt32(((mach_header_64*)mh)->filetype);
                cpuType = OSSwapInt32(((mach_header_64*)mh)->cputype);
        }
        else if ( strncmp((const char*)mh, "!<arch>\n", 8) == 0 ) {
                // is static archive
                switch ( fOptions.architecture() ) {
                        case CPU_TYPE_POWERPC:
                                return ppc::ObjectFileArchiveMachO::MakeReader((const uint8_t*)mh, len, info.path, fOptions.readerOptions());
                        case CPU_TYPE_POWERPC64:
                                return ppc64::ObjectFileArchiveMachO::MakeReader((const uint8_t*)mh, len, info.path, fOptions.readerOptions());
                        case CPU_TYPE_I386:
                                return i386::ObjectFileArchiveMachO::MakeReader((const uint8_t*)mh, len, info.path, fOptions.readerOptions());
                }
                throw "no matching archive reader";
        }
        else {
                throw "unknown file type";      
        }
        
        // bail out if cpu-type does not match requrired architecture
        if ( fOptions.architecture() == cpuType ) {
                // make appropriate reader object
                if ( fileType == MH_OBJECT ) {
                        switch ( cpuType ) {
                                case CPU_TYPE_POWERPC:
                                        return ppc::ObjectFileMachO::MakeReader((class ppc::macho_header*)mh, info.path, fOptions.readerOptions());
                                case CPU_TYPE_POWERPC64:
                                        return ppc64::ObjectFileMachO::MakeReader((class ppc64::macho_header*)mh, info.path, fOptions.readerOptions());
                                case CPU_TYPE_I386:
                                        return i386::ObjectFileMachO::MakeReader((class i386::macho_header*)mh, info.path, fOptions.readerOptions());
                                default:
                                        throw "wrong architecture in object file";
                        }
                }
                else if ( fileType == MH_DYLIB ) {
                        ObjectFile::Reader* dylibReader = NULL;
                        switch ( cpuType ) {
                                case CPU_TYPE_POWERPC:
                                        dylibReader = ppc::ObjectFileDylibMachO::MakeReader((class ppc::macho_header*)mh, info.path, fOptions.readerOptions());
                                        break;
                                case CPU_TYPE_POWERPC64:
                                        dylibReader = ppc64::ObjectFileDylibMachO::MakeReader((class ppc64::macho_header*)mh, info.path, fOptions.readerOptions());
                                        break;
                                case CPU_TYPE_I386:
                                        dylibReader = i386::ObjectFileDylibMachO::MakeReader((class i386::macho_header*)mh, info.path, fOptions.readerOptions());
                                        break;
                                default:
                                        throw "wrong architecture in dylib";
                        }
                        this->addDylib(dylibReader, info);
                        return dylibReader;
                }
                throw "unknown mach-o file type";
        }
        else {
                throw "file does not contain requested architecture";
        }

}


void Linker::createReaders()
{
        std::vector<Options::FileInfo>& files = fOptions.getInputFiles();
        const int count = files.size();
        if ( count == 0 )
                throw "no object files specified";
        // add all direct object, archives, and dylibs
        for (int i=0; i < count; ++i) {
                Options::FileInfo& entry = files[i];
                // ignore /usr/lib/dyld on command line in crt.o build
                if ( strcmp(entry.path, "/usr/lib/dyld") != 0 ) {
                        try {
                                this->addInputFile(this->createReader(entry));
                        }
                        catch (const char* msg) {
                                if ( strstr(msg, "architecture") != NULL ) {
                                        if (  fOptions.ignoreOtherArchInputFiles() ) {
                                                // ignore, because this is about an architecture not in use
                                        }
                                        else {
                                                fprintf(stderr, "ld64 warning: in %s, %s\n", entry.path, msg);
                                        }
                                }
                                else {
                                        throwf("in %s, %s", entry.path, msg);
                                }
                        }
                }
        }
        
        // add first level of indirect dylibs
        fDirectLibrariesComplete = true;
        for (std::vector<ExecutableFile::DyLibUsed>::iterator it=fDynamicLibraries.begin(); it != fDynamicLibraries.end(); it++) {
                this->addIndirectLibraries(it->reader);
        }
        
        // indirect handling depends on namespace
        switch ( fOptions.nameSpace() ) {
                case Options::kFlatNameSpace:
                case Options::kForceFlatNameSpace:
                        // with flat namespace, blindly load all indirect libraries
                        // the indirect list will grow as indirect libraries are loaded
                        for (std::list<IndirectLibrary>::iterator it=fIndirectDynamicLibraries.begin(); it != fIndirectDynamicLibraries.end(); it++) {
                                struct stat statBuffer;
                                if ( stat(it->path, &statBuffer) == 0 ) {
                                        Options::FileInfo info;
                                        info.path = it->path;
                                        info.fileLen = statBuffer.st_size;
                                        info.options.fWeakImport = false;
                                        info.options.fReExport = false;
                                        info.options.fInstallPathOverride = NULL;
                                        it->reader = this->createReader(info);
                                }
                                else {
                                        fprintf(stderr, "ld64 warning: indirect library not found: %s\n", it->path);
                                }
                        }
                        break;
                        
                case Options::kTwoLevelNameSpace:
                        // with two-level namespace we only want to use indirect libraries that are re-exported through a library that is used
                        {
                                bool indirectAdded = true;
                                while ( indirectAdded ) {
                                        indirectAdded = false;
                                        // instantiate a reader for each indirect library and try to find parent that re-exports it
                                        for (std::list<IndirectLibrary>::iterator it=fIndirectDynamicLibraries.begin(); it != fIndirectDynamicLibraries.end(); it++) {
                                                if ( it->reader == NULL ) {
                                                        try {
                                                                struct stat statBuffer;
                                                                if ( stat(it->path, &statBuffer) != 0 ) 
                                                                        throw "file not found";
                                                                        
                                                                Options::FileInfo info;
                                                                info.path = it->path;
                                                                info.fileLen = statBuffer.st_size;
                                                                info.options.fWeakImport = false;
                                                                info.options.fReExport = false;
                                                                info.options.fInstallPathOverride = NULL;
                                                                it->reader = this->createReader(info);
                                                                indirectAdded = true;
                                                        }
                                                        catch (const char* msg) {
                                                                fprintf(stderr, "ld64 warning: indirect library %s could not be loaded: %s\n", it->path, msg);
                                                        }
                                                }
                                                // if an indirect library does not have an assigned parent, look for one
                                                if ( (it->reader != NULL) && (it->reExportParent == NULL) ) {
                                                        // ask each parent if they re-export this dylib
                                                        for (std::set<ObjectFile::Reader*>::iterator pit=it->parents.begin(); pit != it->parents.end(); pit++) {
                                                                if ( (*pit)->reExports(it->reader) ) {
                                                                        it->reExportParent = *pit;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        break;
        }
        
        // add relevant indirect libraries to the end of fDynamicLibraries
        for (std::list<IndirectLibrary>::iterator it=fIndirectDynamicLibraries.begin(); it != fIndirectDynamicLibraries.end(); it++) {
                if ( (it->reExportParent != NULL) || (fOptions.nameSpace() != Options::kTwoLevelNameSpace) ) {
                        ExecutableFile::DyLibUsed dylibInfo;
                        dylibInfo.reader = it->reader;
                        dylibInfo.options.fWeakImport = false;
                        dylibInfo.options.fReExport = false;
                        dylibInfo.options.fInstallPathOverride = NULL;
                        dylibInfo.indirect = true;
                        dylibInfo.directReader = it->reExportParent;
                        fDynamicLibraries.push_back(dylibInfo);
                        if ( fOptions.readerOptions().fTraceIndirectDylibs )
                                printf("[Logging for Build & Integration] Used indirect dynamic library: %s\n", it->path);
                }
        }
}



void Linker::addDylib(ObjectFile::Reader* reader, const Options::FileInfo& info)
{
        if ( fDirectLibrariesComplete ) {
                this->addIndirectLibraries(reader);
        }
        else {
                if ( fOptions.readerOptions().fTraceDylibs )
                        printf("[Logging for Build & Integration] Used dynamic library: %s\n", reader->getPath());
                ExecutableFile::DyLibUsed dylibInfo;
                dylibInfo.reader = reader;
                dylibInfo.options = info.options;
                dylibInfo.indirect = false;
                dylibInfo.directReader = NULL;
                fDynamicLibraries.push_back(dylibInfo);
        }
}


void Linker::addIndirectLibraries(ObjectFile::Reader* reader)
{
        std::vector<const char*>* dependentLibs = reader->getDependentLibraryPaths();
        if ( dependentLibs != NULL ) {
                for (std::vector<const char*>::iterator it=dependentLibs->begin(); it != dependentLibs->end(); it++) {
                        if ( this->haveDirectLibrary(*it) ) {
                                // do nothing, direct library already exists
                        }
                        else if ( this->haveIndirectLibrary(*it, reader) ) {
                                // side effect of haveIndirectLibrary() added reader to parent list
                        }
                        else {
                                // add to list of indirect libraries
                                IndirectLibrary indirectLib;
                                indirectLib.path = *it;
                                indirectLib.fileLen = 0;
                                indirectLib.reader = NULL;
                                indirectLib.parents.insert(reader);
                                indirectLib.reExportParent = NULL;
                                fIndirectDynamicLibraries.push_back(indirectLib);
                                //fprintf(stderr, "add indirect library: %s\n", *it);
                        }
                }
        }
}

bool Linker::haveIndirectLibrary(const char* path, ObjectFile::Reader* parentReader)
{
        for (std::list<IndirectLibrary>::iterator it=fIndirectDynamicLibraries.begin(); it != fIndirectDynamicLibraries.end(); it++) {
                if ( strcmp(path, it->path) == 0 ) {
                        it->parents.insert(parentReader);
                        return true;
                }
                if ( it->reader != NULL ) {
                        const char* installPath = it->reader->getInstallPath();
                        if ( (installPath != NULL) && (strcmp(path, installPath) == 0) )
                                return true;
                }
        }
        return false;
}

bool Linker::haveDirectLibrary(const char* path)
{
        for (std::vector<ExecutableFile::DyLibUsed>::iterator it=fDynamicLibraries.begin(); it != fDynamicLibraries.end(); it++) {
                if ( strcmp(path, it->reader->getPath()) == 0 )
                        return true;
                const char* installPath = it->reader->getInstallPath();
                if ( (installPath != NULL) && (strcmp(path, installPath) == 0) )
                        return true;
        }
        return false;
}




void Linker::createWriter()
{
        const char* path = fOptions.getOutputFilePath();
        switch ( fOptions.architecture() ) {
                case CPU_TYPE_POWERPC:
                        this->setOutputFile(ppc::ExecutableFileMachO::MakeWriter(path, fOptions, fDynamicLibraries));
                        break;
                case CPU_TYPE_POWERPC64:
                        this->setOutputFile(ppc64::ExecutableFileMachO::MakeWriter(path, fOptions, fDynamicLibraries));
                        break;
                case CPU_TYPE_I386:
                        this->setOutputFile(i386::ExecutableFileMachO::MakeWriter(path, fOptions, fDynamicLibraries));
                        break;
                default:
                        throw "unknown architecture";
        }
}


Linker::SymbolTable::SymbolTable(Linker& owner)
 : fOwner(owner), fRequireCount(0)
{
}

void Linker::SymbolTable::require(const char* name)
{
        //fprintf(stderr, "require(%s)\n", name);
        Mapper::iterator pos = fTable.find(name);
        if ( pos == fTable.end() ) {
                fTable[name] = NULL;
                ++fRequireCount;
        }
}

bool Linker::SymbolTable::add(ObjectFile::Atom& atom)
{
        const bool log = false;
        const char* name = atom.getName();
        //fprintf(stderr, "map.add(%p: %s => %p)\n", &fTable, name, &atom);
        Mapper::iterator pos = fTable.find(name);
        if ( pos != fTable.end() ) {
                ObjectFile::Atom* existingAtom = pos->second;
                if ( existingAtom != NULL ) {
                        if ( existingAtom->isTentativeDefinition() ) {
                                if ( atom.isTentativeDefinition() ) {
                                        if ( atom.getSize() > existingAtom->getSize() ) {
                                                // replace common-symbol atom with another larger common-symbol
                                                if ( fOwner.fOptions.warnCommons() ) 
                                                        fprintf(stderr, "ld64: replacing common symbol %s size %lld from %s with larger symbol size %lld from %s\n", 
                                                                        existingAtom->getName(), existingAtom->getSize(), existingAtom->getFile()->getPath(), atom.getSize(), atom.getFile()->getPath());
                                                fOwner.fDeadAtoms.insert(existingAtom);
                                                fTable[name] = &atom;
                                                return true;
                                        }
                                        else {
                                                // keep existing common-symbol atom
                                                if ( fOwner.fOptions.warnCommons() ) {
                                                        if ( atom.getSize() == existingAtom->getSize() ) 
                                                                fprintf(stderr, "ld64: ignoring common symbol %s from %s because already have common from %s with same size\n", 
                                                                        atom.getName(), atom.getFile()->getPath(), existingAtom->getFile()->getPath());
                                                        else
                                                                fprintf(stderr, "ld64: ignoring common symbol %s size %lld from %s because already have larger symbol size %lld from %s\n", 
                                                                        atom.getName(), atom.getSize(), atom.getFile()->getPath(), existingAtom->getSize(), existingAtom->getFile()->getPath());
                                                }
                                                fOwner.fDeadAtoms.insert(&atom);
                                                return false;
                                        }
                                }
                                else {
                                        // have common symbol, now found true defintion
                                        if ( atom.isImportProxy() ) {
                                                // definition is in a dylib, so commons-mode decides how to handle
                                                switch ( fOwner.fOptions.commonsMode() ) {
                                                        case Options::kCommonsIgnoreDylibs:
                                                                if ( fOwner.fOptions.warnCommons() ) 
                                                                        fprintf(stderr, "ld64: using common symbol %s from %s and ignoring defintion from dylib %s\n", 
                                                                                        existingAtom->getName(), existingAtom->getFile()->getPath(), atom.getFile()->getPath());
                                                                fOwner.fDeadAtoms.insert(&atom);
                                                                return false;
                                                        case Options::kCommonsOverriddenByDylibs:
                                                                if ( fOwner.fOptions.warnCommons() ) 
                                                                        fprintf(stderr, "ld64: replacing common symbol %s from %s with true definition from %s\n", 
                                                                                        existingAtom->getName(), existingAtom->getFile()->getPath(), atom.getFile()->getPath());
                                                                fOwner.fDeadAtoms.insert(existingAtom);
                                                                fTable[name] = &atom;
                                                                return true;
                                                        case Options::kCommonsConflictsDylibsError:
                                                                throwf("common symbol %s from %s conflicts with defintion from dylib %s", 
                                                                                existingAtom->getName(), existingAtom->getFile()->getPath(), atom.getFile()->getPath());
                                                }
                                        }
                                        else {
                                                // replace common-symbol atom with true definition from .o file
                                                if ( fOwner.fOptions.warnCommons() ) {
                                                        if ( atom.getSize() < existingAtom->getSize() ) 
                                                                fprintf(stderr, "ld64: warning: replacing common symbol %s size %lld from %s with smaller true definition size %lld from %s\n", 
                                                                                existingAtom->getName(), existingAtom->getSize(), existingAtom->getFile()->getPath(), atom.getSize(), atom.getFile()->getPath());
                                                        else
                                                                fprintf(stderr, "ld64: replacing common symbol %s from %s with true definition from %s\n", 
                                                                                existingAtom->getName(), existingAtom->getFile()->getPath(), atom.getFile()->getPath());
                                                }
                                                fOwner.fDeadAtoms.insert(existingAtom);
                                                fTable[name] = &atom;
                                                return true;
                                        }
                                }
                        }
                        else if ( atom.isTentativeDefinition() ) {
                                // keep existing true definition, ignore new tentative definition
                                if ( fOwner.fOptions.warnCommons() ) {
                                        if ( atom.getSize() > existingAtom->getSize() ) 
                                                fprintf(stderr, "ld64: warning: ignoring common symbol %s size %lld from %s because already have definition from %s size %lld, even though definition is smaller\n", 
                                                        atom.getName(), atom.getSize(), atom.getFile()->getPath(), existingAtom->getFile()->getPath(), existingAtom->getSize());
                                        else
                                                fprintf(stderr, "ld64: ignoring common symbol %s from %s because already have definition from %s\n", 
                                                        atom.getName(), atom.getFile()->getPath(), existingAtom->getFile()->getPath());
                                }
                                fOwner.fDeadAtoms.insert(&atom);
                                return false;
                        }
                        else {
                                // neither existing nor new atom are tentative definitions
                                // if existing is weak, we may replace it
                                if ( existingAtom->isWeakDefinition() ) {
                                        if ( atom.isImportProxy() ) {
                                                // keep weak definition even though one exists in a dylib, because coalescing means dylib's copy may not be used
                                                if ( log ) fprintf(stderr, "keep weak atom even though also in a dylib: %s\n", atom.getName());
                                                fOwner.fDeadAtoms.insert(&atom);
                                                return false;
                                        }
                                        else if ( atom.isWeakDefinition() ) {
                                                // have another weak atom, use existing, mark new as dead
                                                if ( log ) fprintf(stderr, "already have weak atom: %s\n", atom.getName());
                                                fOwner.fDeadAtoms.insert(&atom);
                                                return false;
                                        }
                                        else {
                                                // replace weak atom with non-weak atom
                                                if ( log ) fprintf(stderr, "replacing weak atom %p from %s with %p from %s: %s\n", existingAtom, existingAtom->getFile()->getPath(), &atom, atom.getFile()->getPath(), atom.getName());
                                                fOwner.fDeadAtoms.insert(existingAtom);
                                                fTable[name] = &atom;
                                                return true;
                                        }
                                }
                        }
                        if ( atom.isWeakDefinition() ) {
                                // ignore new weak atom, because we already have a non-weak one
                                return false;
                        }
                        if ( atom.isCoalesableByName() && existingAtom->isCoalesableByName() ) {
                                // both coalesable, so ignore duplicate
                                return false;
                        }
                        fprintf(stderr, "duplicate symbol %s in %s and %s\n", name, atom.getFile()->getPath(), existingAtom->getFile()->getPath());
                }
        }
        fTable[name] = &atom;
        return true;
}

ObjectFile::Atom* Linker::SymbolTable::find(const char* name)
{
        Mapper::iterator pos = fTable.find(name);
        if ( pos != fTable.end() ) {
                return pos->second;
        }
        return NULL;
}


void Linker::SymbolTable::getNeededNames(bool andWeakDefintions, std::vector<const char*>& undefines)
{
        for (Mapper::iterator it=fTable.begin(); it != fTable.end(); it++) {
                if ( (it->second == NULL) || (andWeakDefintions && it->second->isWeakDefinition()) ) {
                        undefines.push_back(it->first);
                }
        }
}




bool Linker::AtomSorter::operator()(ObjectFile::Atom* left, ObjectFile::Atom* right)
{
        // first sort by section order (which is already sorted by segment)
        unsigned int leftSectionIndex  =  left->getSection()->getIndex();
        unsigned int rightSectionIndex = right->getSection()->getIndex();
        if ( leftSectionIndex != rightSectionIndex)
                return (leftSectionIndex < rightSectionIndex);
                
        // with a section, sort by original atom order (.o file order and atom order in .o files)
        return left->getSortOrder() < right->getSortOrder();
}


int main(int argc, const char* argv[])
{
        try {
                // create linker object given command line arguments
                Linker ld(argc, argv);
                
                // open all input files
                ld.createReaders();
                
                // open output file
                ld.createWriter();
                
                // do linking
                ld.link();
        }
        catch (const char* msg) {
                fprintf(stderr, "ld64 failed: %s\n", msg);
                return 1;
        }
        
        return 0;
}