clang 20.1.2 extern template oddity

[jeremyd2019]

https://inbox.sourceware.org/cygwin-apps/ea73fae8-d4ed-3821-bd28-c049ec0ccce9@jdrake.com/T/#me1f8e7940029ad203656f3b22ffa2cc948e9b5e4

/cc @mstorsjo @mati865 @tyan0

#include <stdio.h>
#include <string>

class foo
{
public:
  foo() { m_str.assign("hello"); }

  std::string m_str;

} bar;

int main()
{
  printf("%ld - %s\n", __cplusplus, bar.m_str.c_str());
  return 0;
}

With g++ -O2 -S -o test.gcc.s test.cpp

        .file   "test.cpp"
        .text
        .section        .text$_ZN3fooD1Ev,"x"
        .linkonce discard
        .align 2
        .p2align 4
        .globl  _ZN3fooD1Ev
        .def    _ZN3fooD1Ev;    .scl    2;      .type   32;     .endef
        .seh_proc       _ZN3fooD1Ev
_ZN3fooD1Ev:
.LFB1634:
        subq    $56, %rsp
        .seh_stackalloc 56
        .seh_endprologue
        movq    (%rcx), %rax
        leaq    -24(%rax), %rcx
        cmpq    .refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
        jne     .L6
.L1:
        addq    $56, %rsp
        ret
        .p2align 4,,10
        .p2align 3
.L6:
        movl    $-1, %edx
        lock xaddl      %edx, -8(%rax)
        testl   %edx, %edx
        jg      .L1
        leaq    47(%rsp), %rdx
        call    _ZNSs4_Rep10_M_destroyERKSaIcE
        jmp     .L1
        .seh_endproc
        .def    __main; .scl    2;      .type   32;     .endef
        .section .rdata,"dr"
.LC0:
        .ascii "%ld - %s\12\0"
        .section        .text.startup,"x"
        .p2align 4
        .globl  main
        .def    main;   .scl    2;      .type   32;     .endef
        .seh_proc       main
main:
.LFB1196:
        subq    $40, %rsp
        .seh_stackalloc 40
        .seh_endprologue
        call    __main
        movq    bar(%rip), %r8
        movl    $201703, %edx
        leaq    .LC0(%rip), %rcx
        call    printf
        xorl    %eax, %eax
        addq    $40, %rsp
        ret
        .seh_endproc
        .section .rdata,"dr"
.LC1:
        .ascii "hello\0"
        .section        .text.startup,"x"
        .p2align 4
        .def    _GLOBAL__sub_I_bar;     .scl    3;      .type   32;     .endef
        .seh_proc       _GLOBAL__sub_I_bar
_GLOBAL__sub_I_bar:
.LFB1635:
        pushq   %rsi
        .seh_pushreg    %rsi
        pushq   %rbx
        .seh_pushreg    %rbx
        subq    $40, %rsp
        .seh_stackalloc 40
        .seh_endprologue
        movq    .refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rax
        leaq    bar(%rip), %rbx
        movl    $5, %r8d
        leaq    .LC1(%rip), %rdx
        movq    %rbx, %rcx
        addq    $24, %rax
        movq    %rax, bar(%rip)
.LEHB0:
        call    _ZNSs6assignEPKcm
.LEHE0:
        movq    .refptr.__dso_handle(%rip), %r8
        movq    %rbx, %rdx
        leaq    _ZN3fooD1Ev(%rip), %rcx
        addq    $40, %rsp
        popq    %rbx
        popq    %rsi
        jmp     __cxa_atexit
.L11:
        movq    %rax, %rsi
        movq    %rbx, %rcx
        call    _ZNSsD1Ev
        movq    %rsi, %rcx
.LEHB1:
        call    _Unwind_Resume
        nop
.LEHE1:
        .def    __gxx_personality_seh0; .scl    2;      .type   32;     .endef
        .seh_handler    __gxx_personality_seh0, @unwind, @except
        .seh_handlerdata
.LLSDA1635:
        .byte   0xff
        .byte   0xff
        .byte   0x1
        .uleb128 .LLSDACSE1635-.LLSDACSB1635
.LLSDACSB1635:
        .uleb128 .LEHB0-.LFB1635
        .uleb128 .LEHE0-.LEHB0
        .uleb128 .L11-.LFB1635
        .uleb128 0
        .uleb128 .LEHB1-.LFB1635
        .uleb128 .LEHE1-.LEHB1
        .uleb128 0
        .uleb128 0
.LLSDACSE1635:
        .section        .text.startup,"x"
        .seh_endproc
        .section        .ctors,"w"
        .align 8
        .quad   _GLOBAL__sub_I_bar
        .globl  bar
        .bss
        .align 8
bar:
        .space 8
        .ident  "GCC: (GNU) 13.3.1 20250404"
        .def    _ZNSs4_Rep10_M_destroyERKSaIcE; .scl    2;      .type   32;    .endef
        .def    printf; .scl    2;      .type   32;     .endef
        .def    _ZNSs6assignEPKcm;      .scl    2;      .type   32;     .endef
        .def    __cxa_atexit;   .scl    2;      .type   32;     .endef
        .def    _ZNSsD1Ev;      .scl    2;      .type   32;     .endef
        .def    _Unwind_Resume; .scl    2;      .type   32;     .endef
        .section        .rdata$.refptr.__dso_handle, "dr"
        .globl  .refptr.__dso_handle
        .linkonce       discard
.refptr.__dso_handle:
        .quad   __dso_handle
        .section        .rdata$.refptr._ZNSs4_Rep20_S_empty_rep_storageE, "dr"
        .globl  .refptr._ZNSs4_Rep20_S_empty_rep_storageE
        .linkonce       discard
.refptr._ZNSs4_Rep20_S_empty_rep_storageE:
        .quad   _ZNSs4_Rep20_S_empty_rep_storageE

with clang++ -O2 -S -o test.clang.s test.cpp

        .def    @feat.00;
        .scl    3;
        .type   0;
        .endef
        .globl  @feat.00
.set @feat.00, 0
        .file   "test.cpp"
        .def    __dtor_bar;
        .scl    3;
        .type   32;
        .endef
        .text
        .p2align        4                               # -- Begin function __dtor_bar
__dtor_bar:                             # @__dtor_bar
# %bb.0:
        movq    bar(%rip), %rax
        leaq    -24(%rax), %rcx
        leaq    _ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rdx
        cmpq    %rdx, %rcx
        jne     .LBB0_1
.LBB0_2:
        retq
.LBB0_1:
        movl    $-1, %edx
        lock            xaddl   %edx, -8(%rax)
        testl   %edx, %edx
        jg      .LBB0_2
# %bb.3:
        movq    -16(%rax), %rdx
        addq    $25, %rdx
        jmp     _ZdlPvm                         # TAILCALL
                                        # -- End function
        .def    main;
        .scl    2;
        .type   32;
        .endef
        .globl  main                            # -- Begin function main
        .p2align        4
main:                                   # @main
.seh_proc main
# %bb.0:
        pushq   %rbp
        .seh_pushreg %rbp
        subq    $32, %rsp
        .seh_stackalloc 32
        leaq    32(%rsp), %rbp
        .seh_setframe %rbp, 32
        .seh_endprologue
        callq   __main
        movq    bar(%rip), %r8
        leaq    .L.str(%rip), %rcx
        movl    $201703, %edx                   # imm = 0x313E7
        callq   printf
        xorl    %eax, %eax
        addq    $32, %rsp
        popq    %rbp
        retq
        .seh_endproc
                                        # -- End function
        .def    _GLOBAL__sub_I_test.cpp;
        .scl    3;
        .type   32;
        .endef
        .p2align        4                               # -- Begin function _GLOBAL__sub_I_test.cpp
_GLOBAL__sub_I_test.cpp:                # @_GLOBAL__sub_I_test.cpp
.Lfunc_begin0:
.seh_proc _GLOBAL__sub_I_test.cpp
        .seh_handler __gxx_personality_seh0, @unwind, @except
# %bb.0:
        pushq   %rsi
        .seh_pushreg %rsi
        subq    $32, %rsp
        .seh_stackalloc 32
        .seh_endprologue
        leaq    _ZNSs4_Rep20_S_empty_rep_storageE+24(%rip), %rax
        movq    %rax, bar(%rip)
        leaq    bar(%rip), %rcx
.Ltmp0:
        leaq    .L.str.1(%rip), %rdx
        movl    $5, %r8d
        callq   _ZNSs6assignEPKcm
.Ltmp1:
# %bb.1:
        leaq    __dtor_bar(%rip), %rcx
        addq    $32, %rsp
        popq    %rsi
        jmp     atexit                          # TAILCALL
.LBB2_2:
.Ltmp2:
        movq    %rax, %rsi
        leaq    bar(%rip), %rcx
        callq   _ZNSsD2Ev
        movq    %rsi, %rcx
        callq   _Unwind_Resume
        int3
.Lfunc_end0:
        .seh_handlerdata
        .text
        .seh_endproc
        .section        .xdata,"dr"
        .p2align        2, 0x0
GCC_except_table2:
.Lexception0:
        .byte   255                             # @LPStart Encoding = omit
        .byte   255                             # @TType Encoding = omit
        .byte   1                               # Call site Encoding = uleb128
        .uleb128 .Lcst_end0-.Lcst_begin0
.Lcst_begin0:
        .uleb128 .Ltmp0-.Lfunc_begin0           # >> Call Site 1 <<
        .uleb128 .Ltmp1-.Ltmp0                  #   Call between .Ltmp0 and .Ltmp1
        .uleb128 .Ltmp2-.Lfunc_begin0           #     jumps to .Ltmp2
        .byte   0                               #   On action: cleanup
        .uleb128 .Ltmp1-.Lfunc_begin0           # >> Call Site 2 <<
        .uleb128 .Lfunc_end0-.Ltmp1             #   Call between .Ltmp1 and .Lfunc_end0
        .byte   0                               #     has no landing pad
        .byte   0                               #   On action: cleanup
.Lcst_end0:
        .p2align        2, 0x0
        .text
                                        # -- End function
        .bss
        .globl  bar                             # @bar
        .p2align        3, 0x0
bar:
        .zero   8

        .section        .rdata,"dr"
.L.str:                                 # @.str
        .asciz  "%ld - %s\n"

.L.str.1:                               # @.str.1
        .asciz  "hello"

        .section        .bss,"bw",discard,_ZNSs4_Rep20_S_empty_rep_storageE
        .globl  _ZNSs4_Rep20_S_empty_rep_storageE # @_ZNSs4_Rep20_S_empty_rep_storageE
        .p2align        4, 0x0
_ZNSs4_Rep20_S_empty_rep_storageE:
        .zero   32

        .section        .ctors,"dw"
        .p2align        3, 0x0
        .quad   _GLOBAL__sub_I_test.cpp
        .addrsig
        .addrsig_sym __dtor_bar
        .addrsig_sym __gxx_personality_seh0
        .addrsig_sym _GLOBAL__sub_I_test.cpp
        .addrsig_sym _Unwind_Resume
        .addrsig_sym bar
        .addrsig_sym _ZNSs4_Rep20_S_empty_rep_storageE

Issue is that clang is not importing _ZNSs4_Rep20_S_empty_rep_storageE from libstdc++ as it should.

relevant bits of headers:

  // Inhibit implicit instantiations for required instantiations,
  // which are defined via explicit instantiations elsewhere.
#if _GLIBCXX_EXTERN_TEMPLATE
  // The explicit instantiation definitions in src/c++11/string-inst.cc and
  // src/c++17/string-inst.cc only instantiate the members required for C++17
  // and earlier standards (so not C++20's starts_with and ends_with).
  // Suppress the explicit instantiation declarations for C++20, so C++20
  // code will implicitly instantiate std::string and std::wstring as needed.
# if __cplusplus <= 201703L && _GLIBCXX_EXTERN_TEMPLATE > 0
  extern template class basic_string<char>;
# elif ! _GLIBCXX_USE_CXX11_ABI
  // Still need to prevent implicit instantiation of the COW empty rep,
  // to ensure the definition in libstdc++.so is unique (PR 86138).
  extern template basic_string<char>::size_type
    basic_string<char>::_Rep::_S_empty_rep_storage[];
# elif _GLIBCXX_EXTERN_TEMPLATE > 0
  // Export _M_replace_cold even for C++20.
  extern template void
    basic_string<char>::_M_replace_cold(char *, size_type, const char*,
					const size_type, const size_type);
# endif

on Cygwin (where this is an issue), _GLIBCXX_USE_CXX11_ABI is 0. on MSYS2 (which doesn't have this issue apparently due to not having inline code trying to reference _S_empty_rep_storage[](?) has _GLIBCXX_USE_CXX11_ABI as 1. Both have _GLIBCXX_EXTERN_TEMPLATE 1.

[jeremyd2019]

oh, and the issue goes away with clang with -std=c++20, so it seems to be the extern template class basic_string<char>; branch of the #if causing issues.

here's the asm of clang++ -std=c++20 -O2 -S -o test.clang.20.s test.cpp:

	.def	@feat.00;
	.scl	3;
	.type	0;
	.endef
	.globl	@feat.00
.set @feat.00, 0
	.file	"test.cpp"
	.def	__dtor_bar;
	.scl	3;
	.type	32;
	.endef
	.text
	.p2align	4                               # -- Begin function __dtor_bar
__dtor_bar:                             # @__dtor_bar
# %bb.0:
	movq	bar(%rip), %rax
	leaq	-24(%rax), %rcx
	cmpq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	jne	.LBB0_1
.LBB0_2:
	retq
.LBB0_1:
	movl	$-1, %edx
	lock		xaddl	%edx, -8(%rax)
	testl	%edx, %edx
	jg	.LBB0_2
# %bb.3:
	movq	-16(%rax), %rdx
	addq	$25, %rdx
	jmp	_ZdlPvm                         # TAILCALL
                                        # -- End function
	.def	main;
	.scl	2;
	.type	32;
	.endef
	.globl	main                            # -- Begin function main
	.p2align	4
main:                                   # @main
.seh_proc main
# %bb.0:
	pushq	%rbp
	.seh_pushreg %rbp
	subq	$32, %rsp
	.seh_stackalloc 32
	leaq	32(%rsp), %rbp
	.seh_setframe %rbp, 32
	.seh_endprologue
	callq	__main
	movq	bar(%rip), %r8
	leaq	.L.str(%rip), %rcx
	movl	$202002, %edx                   # imm = 0x31512
	callq	printf
	xorl	%eax, %eax
	addq	$32, %rsp
	popq	%rbp
	retq
	.seh_endproc
                                        # -- End function
	.def	_ZNSsD2Ev;
	.scl	2;
	.type	32;
	.endef
	.section	.text,"xr",discard,_ZNSsD2Ev
	.globl	_ZNSsD2Ev                       # -- Begin function _ZNSsD2Ev
	.p2align	4
_ZNSsD2Ev:                              # @_ZNSsD2Ev
# %bb.0:
	movq	(%rcx), %rax
	leaq	-24(%rax), %rcx
	cmpq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	jne	.LBB2_1
.LBB2_2:
	retq
.LBB2_1:
	movl	$-1, %edx
	lock		xaddl	%edx, -8(%rax)
	testl	%edx, %edx
	jg	.LBB2_2
# %bb.3:
	movq	-16(%rax), %rdx
	addq	$25, %rdx
	jmp	_ZdlPvm                         # TAILCALL
                                        # -- End function
	.def	_ZNSs9_M_mutateEmmm;
	.scl	2;
	.type	32;
	.endef
	.section	.text,"xr",discard,_ZNSs9_M_mutateEmmm
	.globl	_ZNSs9_M_mutateEmmm             # -- Begin function _ZNSs9_M_mutateEmmm
	.p2align	4
_ZNSs9_M_mutateEmmm:                    # @_ZNSs9_M_mutateEmmm
.seh_proc _ZNSs9_M_mutateEmmm
# %bb.0:
	pushq	%r15
	.seh_pushreg %r15
	pushq	%r14
	.seh_pushreg %r14
	pushq	%r13
	.seh_pushreg %r13
	pushq	%r12
	.seh_pushreg %r12
	pushq	%rsi
	.seh_pushreg %rsi
	pushq	%rdi
	.seh_pushreg %rdi
	pushq	%rbp
	.seh_pushreg %rbp
	pushq	%rbx
	.seh_pushreg %rbx
	subq	$56, %rsp
	.seh_stackalloc 56
	.seh_endprologue
	movq	%r8, %r12
	movq	%rdx, %rdi
	movq	%rcx, %r13
	movq	(%rcx), %r15
	movq	-24(%r15), %rbx
	movq	%r9, 40(%rsp)                   # 8-byte Spill
	movq	%r9, %rbp
	subq	%r8, %rbp
	addq	%rbx, %rbp
	leaq	(%r8,%rdx), %rsi
	movq	%rbx, %rax
	subq	%rsi, %rax
	movq	%rax, 32(%rsp)                  # 8-byte Spill
	cmpq	-16(%r15), %rbp
	ja	.LBB3_3
# %bb.1:
	movl	-8(%r15), %eax
	testl	%eax, %eax
	jle	.LBB3_19
# %bb.2:
	movq	(%r13), %r15
.LBB3_3:
	movabsq	$4611686018427387898, %rax      # imm = 0x3FFFFFFFFFFFFFFA
	cmpq	%rax, %rbp
	jae	.LBB3_26
# %bb.4:
	movq	-16(%r15), %rax
	leaq	(%rax,%rax), %r14
	cmpq	%r14, %rbp
	cmovaq	%rbp, %r14
	cmpq	%rax, %rbp
	setbe	%al
	cmovbeq	%rbp, %r14
	cmpq	$4040, %r14                     # imm = 0xFC8
	setb	%cl
	orb	%al, %cl
	jne	.LBB3_6
# %bb.5:
	leal	57(%r14), %eax
	andl	$4095, %eax                     # imm = 0xFFF
	subq	%rax, %r14
	addq	$4096, %r14                     # imm = 0x1000
	movabsq	$4611686018427387897, %rax      # imm = 0x3FFFFFFFFFFFFFF9
	cmpq	%rax, %r14
	cmovaeq	%rax, %r14
.LBB3_6:
	movq	%r14, %rcx
	addq	$25, %rcx
	js	.LBB3_27
# %bb.7:
	movq	%r13, 48(%rsp)                  # 8-byte Spill
	callq	_Znwm
	movq	%rax, %r13
	movq	%r14, 8(%rax)
	movl	$0, 16(%rax)
	testq	%rdi, %rdi
	je	.LBB3_11
# %bb.8:
	leaq	24(%r13), %rcx
	cmpq	$1, %rdi
	jne	.LBB3_10
# %bb.9:
	movzbl	(%r15), %eax
	movb	%al, (%rcx)
.LBB3_11:
	cmpq	%rsi, %rbx
	jne	.LBB3_12
	jmp	.LBB3_15
.LBB3_10:
	movq	%r15, %rdx
	movq	%rdi, %r8
	callq	memcpy
	cmpq	%rsi, %rbx
	je	.LBB3_15
.LBB3_12:
	leaq	(%rdi,%r13), %rax
	movq	40(%rsp), %rcx                  # 8-byte Reload
	addq	%rax, %rcx
	addq	$24, %rcx
	addq	%r15, %rdi
	addq	%r12, %rdi
	movq	32(%rsp), %r8                   # 8-byte Reload
	cmpq	$1, %r8
	jne	.LBB3_14
# %bb.13:
	movzbl	(%rdi), %eax
	movb	%al, (%rcx)
	jmp	.LBB3_15
.LBB3_14:
	movq	%rdi, %rdx
	callq	memcpy
.LBB3_15:
	leaq	-24(%r15), %rcx
	cmpq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	jne	.LBB3_16
.LBB3_18:
	addq	$24, %r13
	movq	48(%rsp), %rax                  # 8-byte Reload
	movq	%r13, (%rax)
	movq	%rax, %r13
.LBB3_23:
	movq	(%r13), %rax
	leaq	-24(%rax), %rcx
	cmpq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	jne	.LBB3_24
.LBB3_25:
	addq	$56, %rsp
	popq	%rbx
	popq	%rbp
	popq	%rdi
	popq	%rsi
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	retq
.LBB3_19:
	cmpq	%rsi, %rbx
	sete	%al
	movq	40(%rsp), %rcx                  # 8-byte Reload
	cmpq	%r12, %rcx
	sete	%dl
	orb	%al, %dl
	jne	.LBB3_23
# %bb.20:
	addq	(%r13), %rdi
	addq	%rdi, %rcx
	addq	%r12, %rdi
	movq	32(%rsp), %r8                   # 8-byte Reload
	cmpq	$1, %r8
	jne	.LBB3_22
# %bb.21:
	movzbl	(%rdi), %eax
	movb	%al, (%rcx)
	jmp	.LBB3_23
.LBB3_22:
	movq	%rdi, %rdx
	callq	memmove
	jmp	.LBB3_23
.LBB3_24:
	movl	$0, -8(%rax)
	movq	%rbp, -24(%rax)
	movb	$0, (%rax,%rbp)
	jmp	.LBB3_25
.LBB3_27:
	callq	_ZSt17__throw_bad_allocv
.LBB3_16:
	movl	$-1, %eax
	lock		xaddl	%eax, -8(%r15)
	testl	%eax, %eax
	jg	.LBB3_18
# %bb.17:
	movq	-16(%r15), %rdx
	addq	$25, %rdx
	callq	_ZdlPvm
	jmp	.LBB3_18
.LBB3_26:
	leaq	.L.str.3(%rip), %rcx
	callq	_ZSt20__throw_length_errorPKc
	int3
	.seh_endproc
                                        # -- End function
	.def	_GLOBAL__sub_I_test.cpp;
	.scl	3;
	.type	32;
	.endef
	.text
	.p2align	4                               # -- Begin function _GLOBAL__sub_I_test.cpp
_GLOBAL__sub_I_test.cpp:                # @_GLOBAL__sub_I_test.cpp
.Lfunc_begin0:
.seh_proc _GLOBAL__sub_I_test.cpp
	.seh_handler __gxx_personality_seh0, @unwind, @except
# %bb.0:
	pushq	%rsi
	.seh_pushreg %rsi
	subq	$32, %rsp
	.seh_stackalloc 32
	.seh_endprologue
	movq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	leaq	24(%rcx), %rdx
	movq	%rdx, bar(%rip)
	leaq	.L.str.1(%rip), %rax
	cmpq	%rax, %rdx
	je	.LBB4_2
# %bb.1:
	xorl	%r8d, %r8d
	jmp	.LBB4_4
.LBB4_2:
	movl	16(%rcx), %ecx
	testl	%ecx, %ecx
	jle	.LBB4_6
# %bb.3:
	movq	bar(%rip), %rax
	movq	-24(%rax), %r8
.LBB4_4:
.Ltmp0:
	leaq	bar(%rip), %rcx
	movl	$5, %r9d
	xorl	%edx, %edx
	callq	_ZNSs9_M_mutateEmmm
.Ltmp1:
# %bb.5:
	movq	bar(%rip), %rax
	movb	$111, 4(%rax)
	movl	$1819043176, (%rax)             # imm = 0x6C6C6568
.LBB4_10:
	leaq	__dtor_bar(%rip), %rcx
	addq	$32, %rsp
	popq	%rsi
	jmp	atexit                          # TAILCALL
.LBB4_6:
	movq	bar(%rip), %rcx
	cmpq	%rax, %rcx
	je	.LBB4_8
# %bb.7:
	movb	$111, 4(%rcx)
	movl	$1819043176, (%rcx)             # imm = 0x6C6C6568
	movq	bar(%rip), %rax
.LBB4_8:
	leaq	-24(%rax), %rcx
	cmpq	.refptr._ZNSs4_Rep20_S_empty_rep_storageE(%rip), %rcx
	je	.LBB4_10
# %bb.9:
	movl	$0, -8(%rax)
	movq	$5, -24(%rax)
	movb	$0, 5(%rax)
	jmp	.LBB4_10
.LBB4_11:
.Ltmp2:
	movq	%rax, %rsi
	leaq	bar(%rip), %rcx
	callq	_ZNSsD2Ev
	movq	%rsi, %rcx
	callq	_Unwind_Resume
	int3
.Lfunc_end0:
	.seh_handlerdata
	.text
	.seh_endproc
	.section	.xdata,"dr"
	.p2align	2, 0x0
GCC_except_table4:
.Lexception0:
	.byte	255                             # @LPStart Encoding = omit
	.byte	255                             # @TType Encoding = omit
	.byte	1                               # Call site Encoding = uleb128
	.uleb128 .Lcst_end0-.Lcst_begin0
.Lcst_begin0:
	.uleb128 .Ltmp0-.Lfunc_begin0           # >> Call Site 1 <<
	.uleb128 .Ltmp1-.Ltmp0                  #   Call between .Ltmp0 and .Ltmp1
	.uleb128 .Ltmp2-.Lfunc_begin0           #     jumps to .Ltmp2
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp1-.Lfunc_begin0           # >> Call Site 2 <<
	.uleb128 .Lfunc_end0-.Ltmp1             #   Call between .Ltmp1 and .Lfunc_end0
	.byte	0                               #     has no landing pad
	.byte	0                               #   On action: cleanup
.Lcst_end0:
	.p2align	2, 0x0
	.text
                                        # -- End function
	.bss
	.globl	bar                             # @bar
	.p2align	3, 0x0
bar:
	.zero	8

	.section	.rdata,"dr"
.L.str:                                 # @.str
	.asciz	"%ld - %s\n"

.L.str.1:                               # @.str.1
	.asciz	"hello"

.L.str.3:                               # @.str.3
	.asciz	"basic_string::_S_create"

	.section	.ctors,"dw"
	.p2align	3, 0x0
	.quad	_GLOBAL__sub_I_test.cpp
	.section	.drectve,"yni"
	.section	.rdata$.refptr._ZNSs4_Rep20_S_empty_rep_storageE,"dr",discard,.refptr._ZNSs4_Rep20_S_empty_rep_storageE
	.p2align	3, 0x0
	.globl	.refptr._ZNSs4_Rep20_S_empty_rep_storageE
.refptr._ZNSs4_Rep20_S_empty_rep_storageE:
	.quad	_ZNSs4_Rep20_S_empty_rep_storageE
	.addrsig
	.addrsig_sym __dtor_bar
	.addrsig_sym __gxx_personality_seh0
	.addrsig_sym _GLOBAL__sub_I_test.cpp
	.addrsig_sym _Unwind_Resume
	.addrsig_sym bar
	.addrsig_sym _ZNSs4_Rep20_S_empty_rep_storageE

[jeremyd2019]

I also just noticed that gcc is using __cxa_atexit while clang is just using atexit. gcc is configured with --enable-__cxa_atexit. I presume some similar option is missing for the Cygwin target in clang?

[jeremyd2019]

I also just noticed that gcc is using __cxa_atexit while clang is just using atexit. gcc is configured with --enable-__cxa_atexit. I presume some similar option is missing for the Cygwin target in clang?

Found that in clang/lib/Driver/ToolChains/Clang.cpp:

  // -fuse-cxa-atexit is default.
  if (!Args.hasFlag(
          options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
          !RawTriple.isOSAIX() && !RawTriple.isOSWindows() &&
              ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
               RawTriple.hasEnvironment())) ||
      KernelOrKext)
    CmdArgs.push_back("-fno-use-cxa-atexit");

should be (!RawTriple.isOSWindows() || RawTriple.getEnvironment() == Triple::Cygnus) ? mingw-w64 has __cxa_atexit should we be using it there too? (!RawTriple.isOSWindows() || RawTriple.isOSCygMing()) ?

[mati865]

Yes, that seems to be the case. There are probably similar issues in a few other checks.

[jeremyd2019]

1. should I open an issue on llvm/llvm-project for the extern template issue. The key factor seems to be gcc built with --with-default-libstdcxx-abi=gcc4-compatible. I don't know if a libstdc++ built like this for mingw-w64 would also exhibit this issue.
2. maybe we could have a fork of llvm/llvm-project under msys2-contrib to collaborate on some of this?

[jeremyd2019]

For comparison, here's the assembly that clang generates on MSYS2 (which does not set --with-default-libstdcxx-abi=gcc4-compatible):

	.def	@feat.00;
	.scl	3;
	.type	0;
	.endef
	.globl	@feat.00
.set @feat.00, 0
	.file	"test.cpp"
	.def	__dtor_bar;
	.scl	3;
	.type	32;
	.endef
	.text
	.p2align	4                               # -- Begin function __dtor_bar
__dtor_bar:                             # @__dtor_bar
# %bb.0:
	movq	bar(%rip), %rcx
	leaq	bar+16(%rip), %rax
	cmpq	%rax, %rcx
	je	.LBB0_1
# %bb.2:
	movq	bar+16(%rip), %rdx
	incq	%rdx
	jmp	_ZdlPvm                         # TAILCALL
.LBB0_1:
	retq
                                        # -- End function
	.def	main;
	.scl	2;
	.type	32;
	.endef
	.globl	main                            # -- Begin function main
	.p2align	4
main:                                   # @main
.seh_proc main
# %bb.0:
	pushq	%rbp
	.seh_pushreg %rbp
	subq	$32, %rsp
	.seh_stackalloc 32
	leaq	32(%rsp), %rbp
	.seh_setframe %rbp, 32
	.seh_endprologue
	callq	__main
	movq	bar(%rip), %r8
	leaq	.L.str(%rip), %rcx
	movl	$201703, %edx                   # imm = 0x313E7
	callq	printf
	xorl	%eax, %eax
	addq	$32, %rsp
	popq	%rbp
	retq
	.seh_endproc
                                        # -- End function
	.def	_GLOBAL__sub_I_test.cpp;
	.scl	3;
	.type	32;
	.endef
	.p2align	4                               # -- Begin function _GLOBAL__sub_I_test.cpp
_GLOBAL__sub_I_test.cpp:                # @_GLOBAL__sub_I_test.cpp
.Lfunc_begin0:
.seh_proc _GLOBAL__sub_I_test.cpp
	.seh_handler __gxx_personality_seh0, @unwind, @except
# %bb.0:
	pushq	%rsi
	.seh_pushreg %rsi
	pushq	%rdi
	.seh_pushreg %rdi
	subq	$40, %rsp
	.seh_stackalloc 40
	.seh_endprologue
	leaq	bar+16(%rip), %rdi
	movq	%rdi, bar(%rip)
	leaq	bar(%rip), %rcx
	movq	$0, bar+8(%rip)
	movb	$0, bar+16(%rip)
.Ltmp0:
	movq	$5, 32(%rsp)
	leaq	.L.str.1(%rip), %r9
	xorl	%edx, %edx
	xorl	%r8d, %r8d
	callq	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm
.Ltmp1:
# %bb.1:
	leaq	__dtor_bar(%rip), %rcx
	addq	$40, %rsp
	popq	%rdi
	popq	%rsi
	jmp	atexit                          # TAILCALL
.LBB2_2:
.Ltmp2:
	movq	%rax, %rsi
	movq	bar(%rip), %rcx
	cmpq	%rdi, %rcx
	je	.LBB2_4
# %bb.3:
	movq	bar+16(%rip), %rdx
	incq	%rdx
	callq	_ZdlPvm
.LBB2_4:
	movq	%rsi, %rcx
	callq	_Unwind_Resume
	int3
.Lfunc_end0:
	.seh_handlerdata
	.text
	.seh_endproc
	.section	.xdata,"dr"
	.p2align	2, 0x0
GCC_except_table2:
.Lexception0:
	.byte	255                             # @LPStart Encoding = omit
	.byte	255                             # @TType Encoding = omit
	.byte	1                               # Call site Encoding = uleb128
	.uleb128 .Lcst_end0-.Lcst_begin0
.Lcst_begin0:
	.uleb128 .Ltmp0-.Lfunc_begin0           # >> Call Site 1 <<
	.uleb128 .Ltmp1-.Ltmp0                  #   Call between .Ltmp0 and .Ltmp1
	.uleb128 .Ltmp2-.Lfunc_begin0           #     jumps to .Ltmp2
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp1-.Lfunc_begin0           # >> Call Site 2 <<
	.uleb128 .Lfunc_end0-.Ltmp1             #   Call between .Ltmp1 and .Lfunc_end0
	.byte	0                               #     has no landing pad
	.byte	0                               #   On action: cleanup
.Lcst_end0:
	.p2align	2, 0x0
	.text
                                        # -- End function
	.bss
	.globl	bar                             # @bar
	.p2align	3, 0x0
bar:
	.zero	32

	.section	.rdata,"dr"
.L.str:                                 # @.str
	.asciz	"%ld - %s\n"

.L.str.1:                               # @.str.1
	.asciz	"hello"

	.section	.ctors,"dw"
	.p2align	3, 0x0
	.quad	_GLOBAL__sub_I_test.cpp
	.addrsig
	.addrsig_sym __dtor_bar
	.addrsig_sym __gxx_personality_seh0
	.addrsig_sym _GLOBAL__sub_I_test.cpp
	.addrsig_sym _Unwind_Resume
	.addrsig_sym bar

[mati865]

1. Dunno, I doubt it would attract much attention
2. I don't mind, but I'm not planning to invest a lot of effort into it.

[jeremyd2019]

1. probably just @mstorsjo either way 😁
2. I'll use my own fork then I guess.

[tyan0]

As you already noticed, setting _GLIBCXX_USE_CXX11_ABI=1 seems to solve the issue.
So, I applied the following patch and confirmed that it works.

--- origsrc/clang-20.1.2.src/lib/Driver/ToolChains/Clang.cpp	2025-04-02 08:44:12.000000000 +0900
+++ src/clang-20.1.2.src/lib/Driver/ToolChains/Clang.cpp	2025-04-15 13:49:14.049895000 +0900
@@ -5739,6 +5739,23 @@ void Clang::ConstructJob(Compilation &C,
     }
   }
 
+#ifdef __CYGWIN__
+  /* This is necessary because cygwin gcc is built with 
+       --with-default-libstdcxx-abi=gcc4-compatible */
+  if (Triple.isOSCygMing()) {
+    auto findMacroDefinition = [&](const std::string &Macro) {
+      auto MacroDefs = Args.getAllArgValues(options::OPT_D);
+      return llvm::any_of(MacroDefs, [&](const std::string &M) {
+        return M == Macro || M.find(Macro + '=') != std::string::npos;
+      });
+    };
+
+    if (types::isCXX(Input.getType())
+        && !findMacroDefinition("_GLIBCXX_USE_CXX11_ABI"))
+      CmdArgs.push_back("-D_GLIBCXX_USE_CXX11_ABI=1");
+  }
+#endif
+
   llvm::Reloc::Model RelocationModel;
   unsigned PICLevel;
   bool IsPIE;

If you could give me any suggestions, I would be happy. Thanks!

[jeremyd2019]

Wow, that works?!? I thought that had to match how libstdc++ was built, but I guess it really is "dual ABI". Makes me wonder why Cygwin couldn't switch the default to gcc's default, and let old binaries continue to use the legacy ABI...

I would not put that in #ifdef __CYGWIN__ and just check Triple.isWindowsCygwinEnvironment() (rather than isOSCygMing(), unless we confirm this is a problem on MinGW also, which I would like to test at some point). This is a workaround entirely dependent on the Cygwin target.

Also, FYI, I opened llvm/llvm-project#135691 and llvm/llvm-project#135701, once there's a Cygwin "toolchain" file that might be a good place for such a workaround (assuming we can find the correct method to add it to).

[mati865]

I have no clue how this works. I haven't been using C++ for a long time, but I'd expect -D_GLIBCXX_USE_CXX11_ABI=1 to introduce incompatibility between Cygwin's GCC and Clang.

[jeremyd2019]

--with-default-libstdcxx-abi=OPTION
Set the default value for the _GLIBCXX_USE_CXX11_ABI macro (see [Macros] (https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html)). The default is OPTION=new which sets the macro to 1, use OPTION=gcc4-compatible to set it to 0. This option does not change the library ABI.

So why is this not left at the default on Cygwin, if it doesn't change the library ABI? Oh, because it changes the ABI of libraries built against libstdc++ I guess

[tyan0]

Wow, that works?!? I thought that had to match how libstdc++ was built, but I guess it really is "dual ABI". Makes me wonder why Cygwin couldn't switch the default to gcc's default, and let old binaries continue to use the legacy ABI...

I would not put that in #ifdef __CYGWIN__ and just check Triple.isWindowsCygwinEnvironment() (rather than isOSCygMing(), unless we confirm this is a problem on MinGW also, which I would like to test at some point). This is a workaround entirely dependent on the Cygwin target.

Thanks! As far as I checked x86_64-w64-mingw32-gcc -Q -v result, mingw compiler does not seem to use --with-default-libstdcxx-abi=gcc4-compatible. So probably mingw clang does not need _GLIBCXX_USE_CXX11_ABI=1.

[jeremyd2019]

OK, I've just confirmed that it does reproduce on mingw-w64 when GCC is built as on Cygwin, so I'm going to open an issue on llvm-project.