静态链接&动态链接

➜  ios cat bar.c
int global = 1;
void fizz(int a) {
    global = a;
}
➜  ios cat main.c
extern int global;
void fizz(int a);
int main() {
    fizz(100 + global);
    return 0;
}

➜  ios xcrun -sdk iphoneos clang -c bar.c main.c -target arm64-apple-ios13.4
➜  ios xcrun -sdk iphoneos clang bar.o main.o -o main -target arm64-apple-ios13.4

➜  ios jtool -S bar.o
0000000000000000 T _fizz
0000000000000020 D _global
➜  ios jtool -S main.o
0000000000000000 T _main
                 U _fizz
                 U _global
➜  ios jtool -S main
0000000100000000 T __mh_execute_header
0000000100007f54 T _fizz
0000000100008000 D _global
0000000100007f74 T _main
                 U dyld_stub_binder

➜  ios xcrun -sdk iphoneos clang -c main.c -o main_dyld.o -target arm64-apple-ios13.4
➜  ios xcrun -sdk iphoneos clang -fPIC -shared bar.c -o libbar.dylib -target arm64-apple-ios13.4
➜  ios xcrun -sdk iphoneos clang main_dyld.o -o main_dyld -L . -l bar -target arm64-apple-ios13.4

➜  ios otool -v main_dyld -s __TEXT __stubs
main_dyld:
Contents of (__TEXT,__stubs) section
0000000100007f88    nop
0000000100007f8c    ldr x16, #0x4074            ; Latency: 4
0000000100007f90    br  x16

uintptr_t fastBindLazySymbol(ImageLoader** imageLoaderCache, uintptr_t lazyBindingInfoOffset)
{
    uintptr_t result = 0;
    // get image 
    if ( *imageLoaderCache == NULL ) {
        // save in cache
        *imageLoaderCache = dyld::findMappedRange((uintptr_t)imageLoaderCache);
        if ( *imageLoaderCache == NULL ) {
            const char* message = "fast lazy binding from unknown image";
            dyld::log("dyld: %s\n", message);
            halt(message);
        }
    }
    
    // bind lazy pointer and return it
    try {
        result = (*imageLoaderCache)->doBindFastLazySymbol((uint32_t)lazyBindingInfoOffset, gLinkContext, 
                                (dyld::gLibSystemHelpers != NULL) ? dyld::gLibSystemHelpers->acquireGlobalDyldLock : NULL,
                                (dyld::gLibSystemHelpers != NULL) ? dyld::gLibSystemHelpers->releaseGlobalDyldLock : NULL);
    }
    catch (const char* message) {
        dyld::log("dyld: lazy symbol binding failed: %s\n", message);
        halt(message);
    }

    // return target address to glue which jumps to it with real parameters restored
    return result;
}

uintptr_t ImageLoaderMachOCompressed::doBindFastLazySymbol(uint32_t lazyBindingInfoOffset, const LinkContext& context,
                                                            void (*lock)(), void (*unlock)())
{
    // <rdar://problem/8663923> race condition with flat-namespace lazy binding
    if ( this->usesTwoLevelNameSpace() ) {
        // two-level namespace lookup does not require lock because dependents can't be unloaded before this image
    }
    else {
        // acquire dyld global lock
        if ( lock != NULL )
            lock();
    }
    
    const uint8_t* const start = fLinkEditBase + fDyldInfo->lazy_bind_off;
    const uint8_t* const end = &start[fDyldInfo->lazy_bind_size];
    if ( lazyBindingInfoOffset > fDyldInfo->lazy_bind_size ) {
        dyld::throwf("fast lazy bind offset out of range (%u, max=%u) in image %s", 
            lazyBindingInfoOffset, fDyldInfo->lazy_bind_size, this->getPath());
    }

    uint8_t type = BIND_TYPE_POINTER;
    uintptr_t address = 0;
    const char* symbolName = NULL;
    uint8_t symboFlags = 0;
    long libraryOrdinal = 0;
    bool done = false;
    uintptr_t result = 0;
    const uint8_t* p = &start[lazyBindingInfoOffset];
    while ( !done && (p < end) ) {
        uint8_t immediate = *p & BIND_IMMEDIATE_MASK;
        uint8_t opcode = *p & BIND_OPCODE_MASK;
        ++p;
        switch (opcode) {
            case BIND_OPCODE_DONE:
                done = true;
                break;
            case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
                libraryOrdinal = immediate;
                break;
            case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
                libraryOrdinal = read_uleb128(p, end);
                break;
            case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
                // the special ordinals are negative numbers
                if ( immediate == 0 )
                    libraryOrdinal = 0;
                else {
                    int8_t signExtended = BIND_OPCODE_MASK | immediate;
                    libraryOrdinal = signExtended;
                }
                break;
            case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
                symbolName = (char*)p;
                symboFlags = immediate;
                while (*p != '\0')
                    ++p;
                ++p;
                break;
            case BIND_OPCODE_SET_TYPE_IMM:
                type = immediate;
                break;
            case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
                if ( immediate >= fSegmentsCount )
                    dyld::throwf("BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB has segment %d which is too large (0..%d)", 
                            immediate, fSegmentsCount-1);
                address = segActualLoadAddress(immediate) + read_uleb128(p, end);
                break;
            case BIND_OPCODE_DO_BIND:
                
            
                result = this->bindAt(context, address, type, symbolName, 0, 0, libraryOrdinal, "lazy ", NULL, true);
                break;
            case BIND_OPCODE_SET_ADDEND_SLEB:
            case BIND_OPCODE_ADD_ADDR_ULEB:
            case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
            case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
            case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
            default:
                dyld::throwf("bad lazy bind opcode %d", *p);
        }
    }   
    
    if ( !this->usesTwoLevelNameSpace() ) {
        // release dyld global lock
        if ( unlock != NULL )
            unlock();
    }
    return result;
}

uintptr_t ImageLoaderMachOCompressed::bindAt(const LinkContext& context, uintptr_t addr, uint8_t type, const char* symbolName, 
                                uint8_t symboFlags, intptr_t addend, long libraryOrdinal, const char* msg, 
                                LastLookup* last, bool runResolver)
{
    const ImageLoader*  targetImage;
    uintptr_t           symbolAddress;
    
    // resolve symbol
    symbolAddress = this->resolve(context, symbolName, symboFlags, libraryOrdinal, &targetImage, last, runResolver);

    // do actual update
    return this->bindLocation(context, addr, symbolAddress, targetImage, type, symbolName, addend, msg);
}