OS X 下动态库的引用

foo.c

#include <stdio.h>

void foo(void)
{
    printf("foo.\n");
}

 

main.c

#include <stdio.h>

extern void foo(void);

int main(void)
{
    foo();
    printf("main.\n");
    return 0;
}

 

编译执行


$ gcc -dynamiclib foo.c -o libfoo.dylib
(-dynamiclib 表示将foo.c编译成一个动态库,
-o libfoo.dylib 用于指定生成的动态库的名称)

$ gcc main.c -L. -lfoo -o main
(-L. 指定当前目录为链接时动态库的查找目录,
-lfoo 指定要链接的动态库为libfoo.dylib,
-o main 指定生成的可执行文件名称为main)

$ ./main
foo.
main.
(在当前目录下执行main,注意要加上 ./)

两种引用


动态库的引用分为链接时引用与运行时引用两种情况。

-L. -lfoo 表示在链接时引用当前目录下的libfoo.dylib,
如果我们把libfoo.dylib移到上一层目录:
$ mv libfoo.dylib ..
这时再次链接:
$ gcc main.c -L. -lfoo -o main
ld: library not found for -lfoo
clang: error: linker command failed with exit code 1 (use -v to see invocation)
会提示出错,再将动态库移回:
$ mv ../libfoo.dylib .
再次链接:
$ gcc main.c -L. -lfoo -o main
执行成功。


在执行上述链接过程时,编译器顺便将动态库libfoo.dylib的install_name记录到了main程序中,
用来在运行时查找并引用该动态库,
查看动态库libfoo.dylib的install_name,运行:
$ otool -D libfoo.dylib
libfoo.dylib:
libfoo.dylib
显示出libfoo.dylib的install_name是libfoo.dylib,
查看一下main程序中记录的install_name是否与此一致:
$ otool -L main
main:
    libfoo.dylib (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
第一条就是动态库libfoo.dylib对应的install_name,显然两者是一致的,main程序在运行时会根据记录的这些install_name在文件系统中查找所依赖的动态库。

关于install_name


(注意:只有动态库才有install_name,应用程序如果引用了某一个动态库,则会在链接时记录该动态库的install_name。)

在链接时,是可以为动态库指定一个install_name的:
$ gcc -dynamiclib foo.c -install_name aaa -o libfoo.dylib
将该动态库的install_name指定为aaa了,如不放心,可以查看一下:
$ otool -D libfoo.dylib 
libfoo.dylib:
aaa
确实为aaa。(注意:如不指定,则会有一个缺省值,如libfoo.dylib)

重新编译main程序:
$ gcc main.c -L. -lfoo -o main
查看一下main程序中记录的install_name:
$ otool -L main
main:
    aaa (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
果然是aaa。这时再次运行main程序:
$ ./main
dyld: Library not loaded: aaa
  Referenced from: /private/tmp/dylib/./main
  Reason: image not found
Trace/BPT trap: 5
出错了,提示找不到动态库aaa,这是因为main程序把aaa当成一个路径,而当前路径下确实没有叫aaa的动态库,
我们可以把libfoo.dylib改名为aaa:
$ mv libfoo.dylib aaa
再次运行:
$ ./main 
foo.
main.
正常。

install_name_tool


顾名思义,install_name_tool就是用来操作install_name的工具,
它既可以改变动态库自身的install_name,也可以改变应用程序中记录的所引用动态库的install_name。

首先将动态库名称由aaa改为bbb:
$ mv aaa bbb
查看一下动态库的install_name:
$ otool -D bbb 
bbb:
aaa
还是之前指定的aaa。
现在我们利用install_name_tool把动态库的install_name也改为bbb:
$ install_name_tool -id bbb bbb
(前一个bbb表示我们指定的install_name,后一个bbb表示动态库文件名)
查看一下修改之后的结果:
$ otool -D bbb 
bbb:
bbb
果然改成了bbb。

这时再查看一下main程序中记录的install_name:
$ otool -L main
main:
    aaa (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
还是之前的aaa,显然如果这时运行main程序还是会失败,因为当前路径下没有叫aaa的动态库文件,
下面我们就将main程序中记录的aaa改为bbb:
$ install_name_tool -change aaa bbb main
(aaa是旧的名称,bbb是新的名称,main表示要操作的文件名称)
查看一下结果:
$ otool -L main
main:
    bbb (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
修改成功,这时再运行一下main程序:
$ ./main 
foo.
main.
运行成功。

现在动态库bbb是和main程序在同一个目录,如果把bbb移到/tmp目录:
$ mv bbb /tmp
我们只需要将main程序中记录的bbb改为/tmp/bbb:
$ install_name_tool -change bbb /tmp/bbb main
查看一下结果:
$ otool -L main
main:
    /tmp/bbb (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
这样也是可以运行的:
$ ./main 
foo.
main.

相对路径也是可以的,现在把tmp目录下的bbb移到当前路径下的temp目录:
$ mkdir temp
$ mv /tmp/bbb temp/
我们只需要将main程序中记录的/tmp/bbb改为./temp/bbb:
$ install_name_tool -change /tmp/bbb ./temp/bbb main
查看一下结果:
$ otool -L main
main:
    ./temp/bbb (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
这样也是可以运行的:
$ ./main 
foo.
main.

@executable_path/ @loader_path/ @rpath/


这三个path是用来表示路径的变量,它们可以用于install_name中,如:
@executable_path/../Frameworks/libAAA.dylib
@loader_path/libBBB.dylib
@rpath/libCCC.dylib
(注意:在使用这三个变量时,后面的“/”不能少。)

@executable_path/


.
├── Frameworks
│   ├── bar.c
│   └── foo.c
└── MacOS
    └── main.c

MacOS/main.c 

#include <stdio.h>

extern void foo(void);
extern void bar(void);

int main(void)
{
    foo();
    bar();
    printf("main.\n");
    return 0;
}

Frameworks/foo.c 

#include <stdio.h>

void foo(void)
{
    printf("foo.\n");
}

Frameworks/bar.c

#include <stdio.h>

void bar(void)
{
    printf("bar.\n");
}

先把foo.c和bar.c做成动态库:
$ gcc foo.c -dynamiclib -install_name @executable_path/../Frameworks/libfoo.dylib -o libfoo.dylib
$ gcc bar.c -dynamiclib -install_name @executable_path/../Frameworks/libbar.dylib -o libbar.dylib

然后利用两个动态库编译main.c:
$ gcc main.c -L../Frameworks -lfoo -lbar -o main

查看一下main程序引用的动态库:
$ otool -L main
main:
    @executable_path/../Frameworks/libfoo.dylib (compatibility version 0.0.0, current version 0.0.0)
    @executable_path/../Frameworks/libbar.dylib (compatibility version 0.0.0, current version 0.0.0)
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
@executable_path/在运行时会替换成当前程序(也就是main程序)所在路径,
我们之前做的动态库文件libfoo.dylib、libbar.dylib正好存在于Frameworks目录下,所以该程序可以运行:
$ ./main 
foo.
bar.
main.

@loader_path/


.
├── A
│   ├── B
│   │   └── bar.c
│   └── foo.c
└── main.c

main.c

#include <stdio.h>

extern void foo(void);

int main(void)
{
    foo();
    printf("main.\n");
    return 0;
}

A/foo.c

#include <stdio.h>

extern void bar(void);

void foo(void)
{
    bar();
    printf("foo.\n");
}

A/B/bar.c

#include <stdio.h>

void bar(void)
{
    printf("bar.\n");
}

先将bar.c编译成动态库:
$ gcc bar.c -dynamiclib -install_name @loader_path/B/libbar.dylib -o libbar.dylib

再将foo.c编译成动态库(用到了libbar.dylib):
$ gcc foo.c -dynamiclib -LB -lbar -install_name @executable_path/A/libfoo.dylib -o libfoo.dylib

最后再编译main程序(用到了libfoo.dylib):
$ gcc main.c -LA -lfoo -o main

执行:
$ ./main
bar.
foo.
main.

main程序依赖于libfoo.dylib,@executable_path/就是main程序的执行路径,
所以libfoo.dylib的install_name设置为@executable_path/A/libfoo.dylib正合适。

libfoo.dylib依赖于libbar.dylib,@loader_path/就是libfoo.dylib的加载路径,
所以libbar.dylib的install_name设置为@loader_path/B/libbar.dylib正合适。
(如果用@executable_path/,则可设置为@executable_path/A/B/libbar.dylib)

@rpath/


一个应用程序只有一个@executable_path/,可能有多个@loader_path/。
@executable_path/表示应用程序执行时路径,@loader_path/表示动态库(包括应用程序)加载时路径,
程序执行时,这两个路径由系统赋值。然而@rpath/则是由用户随意赋值,比前者更为灵活。

.
├── A
├── B
├── C
├── foo.c
└── main.c

main.c

#include <stdio.h>

extern void foo(void);

int main(void)
{
    foo();
    printf("main.\n");
    return 0;
}

foo.c

#include <stdio.h>

void foo(void)
{
    printf("foo.\n");
}

首先编译动态库,把@rpath/加入到install_name中:
$ gcc foo.c -dynamiclib -install_name @rpath/libfoo.dylib -o libfoo.dylib

然后编译应用程序,并添加自定义rpath
$ gcc main.c -L. -lfoo -Wl,-rpath,@loader_path/A/ -Wl,-rpath,@loader_path/B/ -Wl,-rpath,@loader_path/C/ -o main

我们可以用命令查看一下这三个rpath:
$ otool -l main | grep path
         name @rpath/libfoo.dylib (offset 24)
         path @loader_path/A/ (offset 12)
         path @loader_path/B/ (offset 12)
         path @loader_path/C/ (offset 12)
第一行name表示main程序记录的动态库的install_name,后面三个path组成了rpath列表,
运行时@rpath/就被依次替换成了@loader_path/A/ 、@loader_path/B/ 、 @loader_path/C/,
@loader_path/又最终被替换成了动态库(或应用程序)的加载路径。

将libfoo.dylib分别移动到A、B、C三个目录,测试main程序是否可以正常运行:
$ mv libfoo.dylib A/
$ ./main 
foo.
main.
$ mv A/libfoo.dylib B/
$ ./main 
foo.
main.
$ mv B/libfoo.dylib C/
$ ./main 
foo.
main.

Edit By MaHua

posted on 2015-02-11 08:44 刘宝成 阅读(...) 评论(...) 编辑 收藏

导航

统计