关于Linux中so显式链接（dlopen）找不到函数符号地址的问题

摘自：https://blog.csdn.net/qq_27281753/article/details/127202676

问题背景
在做项目的时候，遇到一个so调用问题，既别人提供了一些so库，其中一个so库包含了给我调用的函数，而这个库里面的函数又调用了其他库的函数，这些所有的库都是linux下编译出来的，而项目则是需要在windows下用Qt交叉编译的。这会导致一些问题，（1）如果想要在Qt工具编译项目的时候使用隐式链接方式，把so库链接进去，会出现找不到别人提供的so库中所依赖的linux系统自带的库。（2）如果使用显式链接，既使用dlopen加载so库，然后再使用dlsym加载函数的方式，那么就会出现找不到so库中函数所调用其他库函数的问题。
由于在交叉编译环境中，目前只能使用显示链接的方式调用别人提供的so库，下面就会用一些测试代码，来展示问题是如何出现的以及如何解决问题。
（一）隐式链接和显示链接的结果
首先我们先输出一个最基础的so库libone.so，具体代码如下：
one.h

extern "C" void One();

one.c

#include "one.h"
#include "stdio.h"
void One()
{
printf("One calling\n");
}

然后再写第二个so库libtwo.so，用它调用上面的libone.so中的函数。具体代码如下：
two.h

extern "C" void Two();

two.c

#include "one.h"
#include "two.h"
void Two()
{
One();
}

main.c

#include "dlfcn.h"
#include "stdio.h"
#include "two.h"
typedef void (*pTwo)();

//TEST宏控制是使用dlopen方式还是直接调用Two方式
#define TEST 0
int main()
{
#if TEST
printf("start main\n");
pTwo Two = NULL;
void *pOpen = NULL;
pOpen = dlopen("./libtwo.so", RTLD_LAZY);
if (pOpen == NULL)
{
printf("load libtwo.so fail\n");
return -1;
}

Two = (pTwo)dlsym(pOpen, "Two");
if (Two == NULL)
{
printf("load function Two fail\n");
return -1;
}
#endif
printf("start to call Two\n");
Two();
#if TEST
dlclose(pOpen);
pOpen = NULL;
#endif
return 0;
}

makefile文件

all: libone.so libtwo.so main
main: main.c
g++ main.c -ldl -L. -ltwo -lone -o main
libtwo.so: two.c
g++ two.c -fPIC -shared -o -libtwo.so
libone.so: one.c
g++ one.c -fPIC -shared -o -libone.so
clean:
rm ./main ./libtwo.so ./libone.so

上面的Makefile文件中，main程序是链接了libone.so和libtwo.so两个库，但是libtwo.so并没有把libone.so链接上。
运行结果：

ldd main

ldd libtwo.so

nm -D libtwo.so

可以看到One函数符号没有地址的

（1）没有打开TEST宏的结果：

（2）打开TEST宏的结果：

此时，问题已经出现了，main把两个需要用到的库在编译后已经链接起来了，所以程序中直接调用Two函数的话，可以看到One是被调用起来了。但是如果使用dlopen去加载libtwo.so库，然后再去加载Two函数的方式时，通过nm -D libtwo.so可以看到，One的函数地址是没有的，所以调用Two时，它再调用One就会报错。

libtwo.so和libone.so就相当于别人提供的一些库，libtwo.so中的Two函数就是我们需要使用的函数。那么在项目无法使用第一种方式而只能使用dlopen的方式时，怎么解决该问题呢？可以看到main是可以通过编译链接直接调用Two函数的。那么我们就可以再封装一层，把main看成第三个库，将它封装起来，因为它已经是在Linux环境下能够正常编译和运行的程序了。只需要把main封装成so库，再写一个对外的函数，而这个函数里面直接调用Two，那么就间接的（类似于第一种方式直接的）调用Two函数了。下面就是测试代码和运行结果的展示。

（二）解决显示链接问题的方式
封装出第三个库libthree.so
three.h

extern "C" void Three();

three.c

#include "three.h"
#include "two.h"
void Three()
{
Two();
}

然后再修改一下makefile文件：

all: libone.so libtwo.so libthree.so main
main: main.c
g++ main.c -ldl -L. -lthree -ltwo -lone -o main
//这个libthree.so就相当于上半部分中的main
libthree.so: three.c libtwo.so libone.so
g++ three.c -fPIC -shared -L. -ltwo -lone -o libthree.so
libtwo.so: two.c
g++ two.c -fPIC -shared -o -libtwo.so
libone.so: one.c
g++ one.c -fPIC -shared -o -libone.so
clean:
rm ./main ./libthree.so ./libtwo.so ./libone.so

main.c
main中就把Two改成Three就行：

#include "dlfcn.h"
#include "stdio.h"
#include "three.h"
typedef void (*pThree)();

//TEST宏控制是使用dlopen方式还是直接调用Two方式
#define TEST 0
int main()
{
#if TEST
printf("start main\n");
pThree Three = NULL;
void *pOpen = NULL;
pOpen = dlopen("./libthree.so", RTLD_LAZY);
if (pOpen == NULL)
{
printf("load libthree.so fail\n");
return -1;
}

Three = (pThree)dlsym(pOpen, "Three");
if (Three == NULL)
{
printf("load function Three fail\n");
return -1;
}
#endif
printf("start to call Three\n");
Three();
#if TEST
dlclose(pOpen);
pOpen = NULL;
#endif
return 0;
}

运行结果：

（1）没有打开宏的结果：

（2）打开宏的结果：

总结：从最后的结果可以看到，通过再封装一层的方式，解决了一开始展示的找不到函数符号的问题，使得libthree.so无论是直接的调用Three还是动态加载Three的方式，都能成功得调起了Two函数，直至最终One函数的打印被调用起来。