类似于的SO问题What does gcc's ffast-math actually do? 并且与 Clang optimization levels 的 SO 问题相关，我想知道什么 clang的 -Ofast优化在实际方面的作用，这些是否与 gcc 完全不同，或者这是否比编译器更依赖于硬件。

根据 clang 优化级别的公认答案，-Ofast添加到 -O3优化:-fno-signed-zeros -freciprocal-math -ffp-contract=fast -menable-unsafe-fp-math -menable-no-nans -menable-no-infs .这似乎完全与 float 学相关。但是这些优化对于像 C++ Common mathematical functions 这样的事物在实践中意味着什么？对于 Intel Core i7 等 CPU 上的 float ，这些差异的可靠性如何？

例如，在实际方面:

代码std::isnan(std::numeric_limits<float>::infinity() * 0)为我返回 true -O3 .我相信这是符合 IEEE 数学标准的结果。

与 -Ofast但是，我得到了一个 false 返回值。此外，操作 (std::numeric_limits<float>::infinity() * 0) == 0.0f返回 true。

我不知道这是否与在 gcc 中看到的相同。我不清楚结果是如何依赖于架构的，也不清楚它们是如何依赖编译器的，也不清楚是否有适用于 -Ofast 的标准。 .

如果有人制作了类似一组 unit tests 的东西或 code koans这回答了这个问题，这可能是理想的。我已经开始做这样的事情，但不想重新发明轮子。

最佳答案

描述这些标志中的每一个如何影响每个数学函数需要太多的工作，我将尝试为每个标志提供一个示例。
留给你的负担是看看每一个如何影响一个给定的功能。

-fno-signed-zeros

假设您的代码不依赖于零的符号。
在 FP 算术零不是 absorbing element w.r.t.乘法:0 · x = x · 0 ≠ 0，因为零有一个符号，因此，例如 -3 · 0 = -0 ≠ 0(其中 0 通常表示 +0)。

您可以看到这个 live on Godbolt，其中仅使用 -Ofast

float f(float a)
{
    return a*0;
}

;With -Ofast
f(float):                                  # @f(float)
        xorps   xmm0, xmm0
        ret

;With -O3
f(float): # @f(float)
  xorps xmm1, xmm1
  mulss xmm0, xmm1
  ret

A EOF noted in the comments 这也取决于有限算术。

-freciprocal-math

使用倒数代替除数:a/b = a · (1/b)。
由于FP精度有限，等号真的没有。
乘法比除法快，见 Fog's tables 。
另请参阅 why-is-freciprocal-math-unsafe-in-gcc?。

Godbolt 上的实例:

float f(float a){
    return a/3;
}

;With -Ofast
.LCPI0_0:
        .long   1051372203              # float 0.333333343
f(float):                                  # @f(float)
        mulss   xmm0, dword ptr [rip + .LCPI0_0]
        ret

;With -O3
.LCPI0_0:
  .long 1077936128 # float 3
f(float): # @f(float)
  divss xmm0, dword ptr [rip + .LCPI0_0]
  ret

-ffp-contract=fast

启用 FP 表达式的收缩。
收缩是您可以在 field ℝ 中应用的任何法则的总称，它会产生简化的表达式。
例如，a * k/k = a。

但是，带有+和·的FP数集由于精度有限，一般不是一个域。
此标志允许编译器以正确性为代价收缩 FP 表达式。

Godbolt 上的实例:

float f(float a){
    return a/3*3;
}

;With -Ofast 
f(float):                                  # @f(float)
        ret

;With -O3
.LCPI0_0:
  .long 1077936128 # float 3
f(float): # @f(float)
  movss xmm1, dword ptr [rip + .LCPI0_0] # xmm1 = mem[0],zero,zero,zero
  divss xmm0, xmm1
  mulss xmm0, xmm1
  ret

-menable-unsafe-fp-math

有点上述，但在更广泛的意义上。

Enable optimizations that make unsafe assumptions about IEEE math (e.g. that addition is associative) or may not work for all input ranges. These optimizations allow the code generator to make use of some instructions which would otherwise not be usable (such as fsin on X86).

关于fsin指令的误差精度见this。

Godbolt 的实例，其中 a⁴ 被扩展为 (a^2/sup>)2:

float f(float a){
    return a*a*a*a;
}

f(float):                                  # @f(float)
        mulss   xmm0, xmm0
        mulss   xmm0, xmm0
        ret

f(float): # @f(float)
  movaps xmm1, xmm0
  mulss xmm1, xmm1
  mulss xmm1, xmm0
  mulss xmm1, xmm0
  movaps xmm0, xmm1
  ret

-menable-no-nans

假设代码不生成 NaN 值。
在 previous answer of mine 中，我分析了 ICC 如何通过假设没有 NaN 来处理复数乘法。

大多数 FP 指令会自动处理 NaN。
不过也有异常(exception)，例如 comparisons ，这可以在 Godbolt 的直播中看到

bool f(float a, float b){
    return a<b;
}

;With -Ofast
f(float, float):                                 # @f(float, float)
        ucomiss xmm0, xmm1
        setb    al
        ret

;With -O3
f(float, float): # @f(float, float)
  ucomiss xmm1, xmm0
  seta al
  ret

请注意，这两个版本并不等同，因为 -O3 一个版本排除了 a 和 b 无序的情况，而另一个版本将其包含在 中真 结果。
虽然在这种情况下性能相同，但在复杂的表达式中，这种不对称会导致不同的展开/优化。

-menable-no-infs

就像上面的一样，但对于无穷大。

我无法在 Godbolt 中重现一个简单的例子，但三角函数需要小心处理无穷大，尤其是对于复数。

如果您浏览 a glibc implementation's math dir(例如 sinc)，您会看到很多在使用 -Ofast 进行编译时应该省略的检查。

关于c++ - clang 的 `-Ofast` 选项在实际中有什么作用，特别是对于与 gcc 的任何差异？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45685487/