Failure to compile std::u16string from libstdc++ 12.1 in c++20 mode

[patstew]

I'm getting:

error: undefined symbol: void std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t> >::_M_construct<char16_t const*>(char16_t const*, char16_t const*, std::forward_iterator_tag)

compiling the following simple test case:

#include <string>
#include <string_view>

// static std::u16string clang_string_workaround(const char16_t* a, const char16_t* b) { return {a, b}; }

std::u16string_view sv{u"test"};

std::u16string print() { return std::u16string(sv); }

int main(int, char**) { std::u16string s = print(); }

on clang 13 and 14.0.0, with clang++ -std=c++20 -o test test.cpp. It works fine with -std=c++17. Bizarrely, it also works if you simply uncomment the clang_string_workaround line which isn't even called. It looks like libstdc++ moved that _M_construct function into a separate file recently, which might be related.

[jwakely]

It looks like libstdc++ moved that _M_construct function into a separate file recently

No we didn't. The relevant change is probably jwakely/gcc@5a9572e but I don't know why that would make clang not instantiate the function it calls.

[jwakely]

Very odd. If I remove this function from the <string> code then clang links in C++20 mode:

    __attribute ((__abi_tag__ ("cxx11")))
    inline basic_string<char16_t>
    operator""s(const char16_t* __str, size_t __len)
    { return basic_string<char16_t>{__str, __len}; }

[jwakely]

And if I remove the constexpr specifier from the declaration and definition of the undefined function, it links:

      template<typename _FwdIterator>
        constexpr
        void
        _M_construct(_FwdIterator __beg, _FwdIterator __end,
       std::forward_iterator_tag);

[llvmbot]

@llvm/issue-subscribers-c-20

[tbaederr]

I think this is a small reproducer of the problem:

#define INLINE constexpr

template<typename T>
INLINE
T foo(T a);

int main() {
  int k = foo<int>(5);
}

template<typename T>
INLINE
T foo(T a) {
  return a;
}

Godbolt: https://godbolt.org/z/xoYvvbPKv

The example can be fixed by defining INLINE to nothing (which Jonathan already pointed out), defining it to inline or by just moving the definition of foo() before the point of use: https://godbolt.org/z/qfe38bsnE

[tbaederr]

The problematic code in clang is:

llvm-project/clang/lib/Sema/SemaExpr.cpp

Lines 17970 to 17974 in c6ad690

	else if (Func->isConstexpr())
	// Do not defer instantiations of constexpr functions, to avoid the
	// expression evaluator needing to call back into Sema if it sees a
	// call to such a function.
	InstantiateFunctionDefinition(PointOfInstantiation, Func);

Replacing that else if with else if (false) makes the reproducer from above work (but breaks a ton of test cases of course). As far as I understand, delayed constexpr instantiation is simply not implemented in clang. I wonder what a good way to address this would be. @zygoloid, do you maybe have some pointers on the matter?

[tbaederr]

#55315, #37522 and #16992 are probably the same problem, or at least closely related.