简单浮点计算的GCC和Clang结果不一致 上下文序列不同部分的示例Clang 的 Ghidra 反编译GCC 的 Ghidra 反编译

如何解决简单浮点计算的GCC和Clang结果不一致 上下文序列不同部分的示例Clang 的 Ghidra 反编译GCC 的 Ghidra 反编译

在我的 Intel 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 中错误的表现吗？
4. 这是 GCC 中错误的表现吗？

-ffp-contract=off

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,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。