CUDA: Host-side virtual destructor of template class leaks into PTX as weak function

[mkuron]

Consider the following bit of code:

void _Adjust_manually_vector_aligned()
{}

template <size_t>
constexpr void _Deallocate() {
    _Adjust_manually_vector_aligned();
}

struct basic_string {
    constexpr ~basic_string() {
        _Deallocate<8>();
    }
};

template <class Var_t>
class E {
  virtual ~E() = default;
  basic_string _name;
};

template class E<float>;

Including this into a CUDA file (you don't even have to use the class in a device-side function or variable) leads to errors like ptxas fatal : Unresolved extern function '_Z31_Adjust_manually_vector_alignedv' or, when compiling with -fgpu-rdc, corresponding errors from nvlink. The resulting PTX contains unreferenced .weak .funcs of the defaulted virtual destructor. This bears some similarity to #98151, but the circumstances under which the extraneous symbol is emitted differ.

The code for basic_string and the functions it calls was reduced from https://github.com/microsoft/STL/blob/vs-2022-17.0/stl/inc/xstring and https://github.com/microsoft/STL/blob/vs-2022-17.0/stl/inc/xmemory. The current issue makes it impossible to use std::string in template classes with defaulted virtual destructors when using CUDA on Windows in C++20 mode.

Godbolt: https://godbolt.org/z/7MTda4Kq4

NVCC does not show this issue, it never generates .weak .func symbols for host-side destructors. Clang appears to only be generating these extraneous .weak .func symbols for code that exactly follows the above pattern; eliminating the templates, the virtual, the default, or the constexprs makes the problem go away.

[yxsamliu]

Still reproducible with clang trunk. And it affects HIP too:

lld: error: undefined hidden symbol: _Adjust_manually_vector_aligned()
>>> referenced by /tmp/vdtor-gfx906-b394c5.o:(E<float>::~E())
>>> referenced by /tmp/vdtor-gfx906-b394c5.o:(E<float>::~E())
>>> referenced by /tmp/vdtor-gfx906-b394c5.o:(E<float>::~E())
>>> referenced 1 more times

I will take a look.

[yxsamliu]

The cause of the link error:

Consider device compilation only.

In AST, there is only one dtor for E<float>. clang infers host device attr of dtor of E<float> based on its base dtor, dtors of ancestor classes, and dtors of members. Since base dtor of E<float> is default, it is implicit host device. Since dtor of basic_string is constexpr, it is implicit host device. Therefore dtor of E<float> in AST is inferred as implicit host device.

C++ requires emitting virtual dtor and vtbl for explicit template class instantiation. Since dtor of E<float> is virtual and has implicit device attr, dtor of E<float> is emitted, which causes dtor of basic_string emitted, which causes _Deallocate<8>() emitted, which causes call of host function _Adjust_manually_vector_aligned.

Since host function _Adjust_manually_vector_aligned is not emitted, it causes undefined symbol in linker.

There are two issues spotted:

1. the deferred diag failed to diagnose calling of host function in host device function in device compilation. this can be further divided into two issuse:
   1a. the deferred diag visitor does not visit dtor of member when visiting dtor, which it should
   1b. the deferred diag visitor does not visit dtor of explicit template class instantiation, which it should

By fixing this issue, clang will diag the issue in compilation instead of linking.

2. when inferring host device attr of virtual dtor of explicit template class instantiation, clang should be conservative since it is sure to be emitted. Since an implicit host device function may call a host function, clang cannot assume it is always available on device. For example, in the above testcase, when inferring host device attr for dtor of E<float>, clang cannot infer device attr from dtor of basic_string since it may call host function. This will make dtor of E<float> not implicit device, therefore will not be emitted.