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

Question

我有一个 C++ 动态库(在 macOS 上)，它有一个模板化函数，带有一些在公共(public) 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)

此测试程序链接失败，因为缺少指针:

// 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*)

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

造成这种情况的原因被 clang 对 __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++ 仅在指针重载时忽略可见性属性，并且，就像 clang - 并且与该警告一致 - 它发出代码:

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

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

用one和满足g++的重载的区别不满意它与其他的区别是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 不是指针或引用类型。区别在于:

• 要键入的(具有可见性的指针或引用...) D

和:

• 具有可见性的(指针或类型引用 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) 的实例化应该是动态可见的函数，限定模板函数的类型本身具有可见性属性。根据 GCC 的 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也是如此:

$ 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 会得到相同的结果