GCC 和 Clang 之间的结果不一致，用于简单的浮点计算

问：

在我的英特尔 x86_64 机器上，此C++代码在 Clang 和 GCC 上生成不同的序列：

#include <iostream>

namespace {

template<typename Out>
constexpr auto caster{[](auto x) constexpr {
        return static_cast<Out>(x);
}};

}  // namespace

auto main() -> int {
        constexpr auto fl{caster<double>};

        constexpr double ellipse_b_start{1.0};
        constexpr double ellipse_b_end{150.0};
        constexpr long ellipse_b_count{12347};

        constexpr double ellipse_b_step{(ellipse_b_end - ellipse_b_start) /
                                        fl(ellipse_b_count)};

        std::ios::sync_with_stdio(false);
        std::cout << std::hexfloat;

        for (long i{0}; i < ellipse_b_count; i++) {
                auto ellipse_b{ellipse_b_start + ellipse_b_step * fl(i)};

                std::cout << ellipse_b << '\n';
        }
}

IEEE 754 明确定义了加法和乘法，因此我希望我的序列同样是一个数学常数。

传统上，英特尔x87扩展精度浮点寄存器将受到指责。但这是一个现代的 Intel x86_64 CPU，所以大概 AVX 或 SSE 用于浮点而不是 x87？

我的问题

1. GCC 和 Clang 之间行为不同的原因是什么？
2. 如何在两个编译器上获得完全相同的数字序列？序列中的数字应该快速生成。
3. 这是 Clang 中 bug 的表现吗？
4. 这是 GCC 中错误的体现吗？

-ffp-contract=关闭

Eric Postpischil 提出了这个编译器选项作为解决方案。虽然它可能是这个问题的修复方法，但当应用于我的完整代码时，它作为解决方案是有问题的（上面只是一个例子），因为编译器选项将应用于整个编译单元，这是不可取的性能和其他原因。

其他信息：

GCC 版本 11.1.0。

Clang 是 12.0.1。

GCC 和 Clang 都根据以下选项编译我的代码：

-std=c++20 -pedantic -g -march=native -flto -O3 -fno-exceptions

CPU是i5-8300H。

如果有人想看一看，我也可以提供二进制文件。

上下文

代码的动机是比较分析函数的几种不同实现，其中所讨论的序列提供了要比较不同实现的输入。这就是为什么我希望序列即使在编译器之间也是可预测的。我基本上希望能够将输入的顺序视为固定的/一成不变的。

序列中不同部分的示例

海湾合作委员会：

...
0x1.59973622ca91bp+0
0x1.5cae14b13b7c3p+0
0x1.5fc4f33fac66cp+0
0x1.62dbd1ce1d515p+0
0x1.65f2b05c8e3bdp+0
...

铛：

...
0x1.59973622ca91bp+0
0x1.5cae14b13b7c4p+0
0x1.5fc4f33fac66cp+0
0x1.62dbd1ce1d515p+0
0x1.65f2b05c8e3bep+0
...

Clang 的序列和 GCC 的序列确实趋于同步，连续中永远不会有很多不一致的点。

Clang 的 Ghidra 反编译

int main(void)

{
        undefined auVar1 [16];
        basic_ostream *pbVar2;
        long lVar3;
        long in_FS_OFFSET;
        undefined in_XMM1 [16];
        char local_21;
        long local_20;
        
        local_20 = *(long *)(in_FS_OFFSET + 0x28);
        lVar3 = 0;
        std::ios_base::sync_with_stdio(false);
        *(uint *)(_ITM_deregisterTMCloneTable + *(long *)(std::cout + -0x18)) =
             *(uint *)(_ITM_deregisterTMCloneTable + *(long *)(std::cout + -0x18)) | 0x104;
        do {
                auVar1 = vcvtsi2sd_avx(in_XMM1,lVar3);
                auVar1 = vmulsd_avx(auVar1,ZEXT816(0x3f88b6f473875453));
                auVar1 = vaddsd_avx(auVar1,ZEXT816(0x3ff0000000000000));
                pbVar2 = std::basic_ostream<char,std::char_traits<char>>::_M_insert_double_
                                   (SUB168(auVar1,0));
                local_21 = '\n';
                std::__ostream_insert_char_std__char_traits_char__(pbVar2,&local_21,1);
                lVar3 = lVar3 + 1;
        } while (lVar3 != 0x303b);
        if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
                return 0;
        }
                    /* WARNING: Subroutine does not return */
        __stack_chk_fail();
}

GCC 的 Ghidra 反编译

undefined8 main(void)

{
        undefined auVar1 [16];
        basic_ostream *pbVar2;
        long lVar3;
        long in_FS_OFFSET;
        undefined in_YMM1 [32];
        char local_21;
        long local_20;
        
        lVar3 = 0;
        local_20 = *(long *)(in_FS_OFFSET + 0x28);
        std::ios_base::sync_with_stdio(false);
        *(uint *)(_ITM_deregisterTMCloneTable + *(long *)(std::cout + -0x18)) =
             *(uint *)(_ITM_deregisterTMCloneTable + *(long *)(std::cout + -0x18)) | 0x104;
        do {
                auVar1 = vxorpd_avx(SUB3216(in_YMM1,0),SUB3216(in_YMM1,0));
                in_YMM1 = ZEXT1632(auVar1);
                auVar1 = vcvtsi2sd_avx(auVar1,lVar3);
                lVar3 = lVar3 + 1;
                auVar1 = vfmadd132sd_fma(auVar1,ZEXT816(0x3ff0000000000000),
                                         ZEXT816(0x3f88b6f473875453));
                pbVar2 = std::basic_ostream<char,std::char_traits<char>>::_M_insert_double_
                                   (SUB168(auVar1,0));
                local_21 = '\n';
                std::__ostream_insert_char_std__char_traits_char__(pbVar2,&local_21,1);
        } while (lVar3 != 0x303b);
        if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
                return 0;
        }
                    /* WARNING: Subroutine does not return */
        __stack_chk_fail();
}

请注意 GCC 如何执行融合乘加操作，而 Clang 则不执行。我想这可能是差异的原因吗？但是，有没有一种好方法可以防止序列术语的差异呢？

我之前说过我会接受内联组装解决方案，但现在我想到这一点，我实际上想要一个跨平台的解决方案。如果没有更好的方法，我会尝试使用 -ffp-contract。