[Bug c++/109464] New: gcc does not instantiate constructor for explicitly instantiated template

[Bug c++/109464] New: gcc does not instantiate constructor for explicitly instantiated template

[lh_mouse at 126 dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

            Bug ID: 109464
           Summary: gcc does not instantiate constructor for explicitly
                    instantiated template
           Product: gcc
           Version: 12.2.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: lh_mouse at 126 dot com
  Target Milestone: ---

Created attachment 54824
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=54824&action=edit
unreduced testcase

Attached is a preprocessed file. I don't know how to reduce it for absence of a
function.


```
template<typename charT>
class basic_shallow_string
  {
    static_assert(!is_array<charT>::value, "invalid character type");
    static_assert(is_trivial<charT>::value, "characters must be trivial");
    template<typename, typename> friend class basic_cow_string;

  private:
    const charT* m_ptr;
    size_t m_len;

  public:
    explicit constexpr
    basic_shallow_string(const charT* ptr) noexcept
      : m_ptr(ptr), m_len(noadl::xstrlen(ptr))
      { }

  public:
    constexpr
    const charT*
    c_str() const noexcept
      { return this->m_ptr;  }

    constexpr
    size_t
    length() const noexcept
      { return this->m_len;  }

(... more member functions follow ...)
  };

extern template class basic_shallow_string<char>;
```

And in 'cow_string.cpp' I have 

```
#include "cow_string.hpp"
namespace rocket {

template class basic_shallow_string<char>;

(... more explicit instantiations follow ...)
}  // namespace rocket
```

This explicit instantiation instantiates all inline member functions above, but
not the constructor. I have examined assembly output, and there is no
constructor. Unless optimization is enabled, this causes undefined references:

```
/usr/bin/ld: asteria/repl/bin_asteria-commands.o: in function
`rocket::basic_shallow_string<char> rocket::sref<char>(char const*)':
/home/lh_mouse/GitHub/asteria/asteria/repl/../../rocket/cow_string.hpp:97:
undefined reference to
`rocket::basic_shallow_string<char>::basic_shallow_string(char const*)'
collect2: error: ld returned 1 exit status
```

This happens only with the constructor.

[Bug c++/109464] gcc does not instantiate constructor for explicitly instantiated template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Created attachment 54825
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=54825&action=edit
failed attempt at reducing

This was my trial on reducing the testcase but it failed. In that the symbol is
defined correctly still.

[Bug c++/109464] gcc does not instantiate constructor for explicitly instantiated template

[lh_mouse at 126 dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

--- Comment #2 from LIU Hao <lh_mouse at 126 dot com> ---
shouldn't this be classified as wrong code?

[Bug c++/109464] gcc does not instantiate constructor for explicitly instantiated template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to LIU Hao from comment #2)
> shouldn't this be classified as wrong code?

It is at least a link-failure. Wrong code might be a strech here.

[Bug c++/109464] gcc does not instantiate constructor for explicitly instantiated template

[lh_mouse at 126 dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

LIU Hao <lh_mouse at 126 dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to fail|                            |10.4.0, 9.5.0

--- Comment #4 from LIU Hao <lh_mouse at 126 dot com> ---
Manually reduced testcase:
(godbolt: https://gcc.godbolt.org/z/YsaoM78vM)

```
template<typename T>
struct shallow
 {
   int len;
   constexpr shallow() : len(0) { }
  };

template<typename T>
struct use_shallow
  {
   static constexpr shallow<T> s_zstr = { };
   static_assert(s_zstr.len == 0);
  };

extern template struct shallow<char>;
extern template struct use_shallow<char>;

template struct shallow<char>;
template struct use_shallow<char>;
```

Constructor of `shallow` is lost. All GCC versions are affected.

[Bug c++/109464] gcc does not instantiate constructor for explicitly instantiated template

[lh_mouse at 126 dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109464

--- Comment #5 from LIU Hao <lh_mouse at 126 dot com> ---
Additional information:

I tried splitting the two class templates into two separate .cpp files, so the
explicit instantiation of `basic_shallow_string<char>` should not be subject to
the instantiation of `basic_cow_string<char>`. This made GCC emit the
constructor correctly (checked by examining assembly), but still failed to the
very same undefined reference.

At the moment, a temporary workaround is to mark the constructor of
`basic_shallow_string` as `always_inline`. This works for GCC 10, 11 and 12.
Haven't checked GCC 9 as it's no longer available from APT sources of my
current machine.