Question

我有一个C ++动态库（在macOS上），它有一个模板化的函数，带有一些在公共API中导出的显式实例化。客户端代码只能看到模板声明;他们不知道里面发生了什么，并依赖这些实例在链接时可用。

出于某种原因，只有部分显式实例化在动态库中可见。

这是一个简单的例子：

// libtest.cpp
#define VISIBLE __attribute__((visibility("default")))

template<typename T> T foobar(T arg) {
    return arg;
}

template int  VISIBLE foobar(int);
template int* VISIBLE foobar(int*);

我希望两个实例都可见，但只有非指针实例是：

$ clang++ -dynamiclib -O2 -Wall -Wextra -std=c++1z -stdlib=libc++ -fvisibility=hidden -fPIC libtest.cpp -o libtest.dylib
$ nm -gU libtest.dylib | c++filt
0000000000000f90 T int foobar<int>(int)

此测试程序无法链接，因为缺少指针1：

// client.cpp
template<typename T> T foobar(T);  // assume this was in the library header

int main() {
    foobar<int>(1);
    foobar<int*>(nullptr);
    return 0;
}

$ clang++ -O2 -Wall -Wextra -std=c++1z -stdlib=libc++ -L. -ltest client.cpp -o client
Undefined symbols for architecture x86_64:
  "int* foobar<int*>(int*)", referenced from:
      _main in client-e4fe7d.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

类型和可见性之间似乎存在某种联系。如果我将返回类型更改为void，它们都是可见的（即使模板参数仍然是指针或其他）。特别奇怪的是，这两者都出口了：

template auto VISIBLE foobar(int)  -> int;
template auto VISIBLE foobar(int*) -> int*;

这是一个错误吗？为什么apparent syntactic sugar会改变行为？

如果我将模板定义更改为可见，它可以工作，但它似乎不理想，因为只应导出这些实例中的一小部分...而且我仍然想要了解为什么会发生这种情况，无论哪种方式。

我正在使用Apple LLVM 8.0.0版（clang-800.0.42.1）。

Answer 1

您的问题在linux上可以重现：

$ clang++ --version
clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)
Target: x86_64-pc-linux-gnu
Thread model: posix

$ clang++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden \
-fPIC libtest.cpp -o libtest.so

$ nm -C libtest.so | grep foobar
0000000000000620 W int foobar<int>(int)
0000000000000630 t int* foobar<int*>(int*)

非指针重载是弱全局的，但指针重载是本地

铿锵声对__attribute__的懈怠诊断模糊了这个原因语法扩展，毕竟是GCC的发明。如果我们编译 g ++而不是我们得到：

$ g++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden -fPIC libtest.cpp -o libtest.so
libtest.cpp:9:36: warning: ‘visibility’ attribute ignored on non-class types [-Wattributes]
 template int * VISIBLE foobar(int *);
                                    ^

请注意，g ++仅在指针重载中忽略visibility属性，并且，就像clang一样 - 并且与该警告一致 - 它会发出代码：

$ nm -C libtest.so | grep foobar
0000000000000610 W int foobar<int>(int)
0000000000000620 t int* foobar<int*>(int*)

显然clang正在做同样的事情，但没有告诉我们原因。

满足g ++的重载与one和。之间的差异另一方面不满意的是int和int *之间的区别。在此基础上，我们希望g++对变更感到满意：

template int  VISIBLE foobar(int);
//template int * VISIBLE foobar(int *);
template float VISIBLE foobar(float);

所以它是：

$ g++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden -fPIC libtest.cpp -o libtest.so
$ nm -C libtest.so | grep foobar
0000000000000650 W float foobar<float>(float)
0000000000000640 W int foobar<int>(int)

clang也是如此：

$ clang++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden -fPIC libtest.cpp -o libtest.so
$ nm -C libtest.so | grep foobar
0000000000000660 W float foobar<float>(float)
0000000000000650 W int foobar<int>(int)

对于T非指针类型的重载，它们都可以执行您想要的操作，但是不是T指针类型。

然而，您在此处所面临的是不禁止动态可见功能返回指针而不是非指针。如果，它无法逃脱通知 visibility就像那样破碎了。这只是对表格类型的禁令：

D __attribute__((visibility("...")))

其中D是指针或引用类型，与表单类型不同：

E __attribute__((visibility("..."))) *

或：

E __attribute__((visibility("..."))) &

其中E 不是指针或引用类型。区别在于：

A（具有可见性的指针或引用...）以键入 D

和

A（具有 E 的指针或引用）具有可见性......

请参阅：

$ cat demo.cpp 
int  xx ;
int __attribute__((visibility("default"))) * pvxx; // OK
int * __attribute__((visibility("default"))) vpxx; // Not OK
int __attribute__((visibility("default"))) & rvxx = xx; // OK,
int & __attribute__((visibility("default"))) vrxx = xx; // Not OK


$ g++ -shared -Wall -Wextra -std=c++1z -fvisibility=hidden -o libdemo.so demo.cpp 
demo.cpp:3:46: warning: ‘visibility’ attribute ignored on non-class types [-Wattributes]
 int * __attribute__((visibility("default"))) vpxx; // Not OK
                                              ^
demo.cpp:5:46: warning: ‘visibility’ attribute ignored on non-class types [-Wattributes]
 int & __attribute__((visibility("default"))) vrxx = xx; // Not OK
                                          ^

$ nm -C libdemo.so | grep xx
0000000000201030 B pvxx
0000000000000620 R rvxx
0000000000201038 b vpxx
0000000000000628 r vrxx
0000000000201028 b xx

OK声明成为全局符号;不好的人变成了本地人，并且只有前者是动态可见的：

nm -CD libdemo.so | grep xx
0000000000201030 B pvxx
0000000000000620 R rvxx

这种行为是合理的。我们不能指望编译器属性指向或指向的指针或引用的全局，动态可见性指的是没有全局或动态可见性的东西。

这种合理的行为似乎只会让您的目标受挫，因为 - 正如您现在可能看到的那样：

template int  VISIBLE foobar(int);
template int* VISIBLE foobar(int*);

并不代表你的想法。您认为，对于给定类型U，

template U VISIBLE foobar(U);

声明一个模板实例化具有default的函数可见性，接受类型U的参数并返回相同的参数。事实上，它声明了一个模板实例化函数，它接受一个参数键入U并返回类型：

U __attribute__((visibility("default")))

允许U = int，但不允许使用U = int *。

表达您对template<typename T> T foobar(T arg)的即时消息的意图应该是动态可见的函数，限定模板函数的类型本身具有visibility属性。根据海湾合作委员会的documentation of the __attribute__ syntax - 诚然没有具体说明模板 - 你必须创建一个属性在定义以外的声明中对函数进行限定。如此顺从有了这个，你就像修改你的代码一样：

// libtest.cpp
#define VISIBLE __attribute__((visibility("default")))

template<typename T> T foobar(T arg) VISIBLE;

template<typename T> T foobar(T arg) {
    return arg;
}

template int  foobar(int);
template int* foobar(int*);

g ++不再有任何抱怨：

$ g++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden -fPIC libtest.cpp -o libtest.so
$ nm -CD libtest.so | grep foobar
0000000000000640 W int foobar<int>(int)
0000000000000650 W int* foobar<int*>(int*)

并且两个重载都是动态可见的。铿锵声也是如此：

$ clang++ -shared -O2 -Wall -Wextra -std=c++1z -fvisibility=hidden -fPIC libtest.cpp -o libtest.so
$ nm -CD libtest.so | grep foobar
0000000000000650 W int foobar<int>(int)
0000000000000660 W int* foobar<int*>(int*)

运气好的话，Mac OS上的clang会有相同的结果

为什么只有一些C ++模板实例在共享库中导出？

1 个答案: