gcc -fno-trapping-math选项作用及优化示例、资料咨询

Alright, let's clear up the confusion here—you're right that some optimizations (like FMA usage or common subexpression elimination) still happen with -ftrapping-math, because that option doesn't target those. The key is understanding exactly what -ftrapping-math does restrict (and thus what -fno-trapping-math allows): optimizations that would change the set of floating-point traps that get triggered, beyond just merging operations that would trap anyway.

Example 1: Optimizing Around Invalid Operation Checks #

Consider this code that handles invalid sqrt inputs:

#include <math.h>

double safe_sqrt(double x) {
    double result = sqrt(x);
    if (isnan(result)) {
        return 0.0;
    }
    return result;
}

• With -fno-trapping-math (the default), the compiler assumes floating-point traps (like FE_INVALID for negative sqrt inputs) are disabled. It can optimize this to:

  double safe_sqrt(double x) {
      return x >= 0.0 ? sqrt(x) : 0.0;
  }
  

  This skips the sqrt call entirely for negative x, avoiding the invalid operation trap.
• With -ftrapping-math, this optimization is blocked. The compiler must preserve the original sqrt call for negative x—because the original code would trigger an FE_INVALID trap, and the optimized version would not.

Example 2: Reordering Trap-Prone Operations #

Take this code that conditionally avoids a division by zero:

double conditional_divide(double a, double b) {
    double inv_a = 1.0 / a;
    if (b == 0.0) {
        return inv_a;
    }
    return inv_a + 1.0 / b;
}

• With -fno-trapping-math, the compiler can reorder operations (e.g., calculate 1.0/b before checking b == 0.0) since it assumes division-by-zero traps won't fire.
• With -ftrapping-math, this reordering is forbidden. The original code only triggers a division-by-zero trap if b != 0.0; reordering would trigger it even when b == 0.0, changing the trap behavior.

Example 3: Constant-Folding Trap-Inducing Expressions #

Look at this simple function:

double invalid_log() {
    return log(-1.0);
}

• With -fno-trapping-math, the compiler folds this directly to NaN at compile time, skipping the runtime log call that would trigger an FE_INVALID trap.
• With -ftrapping-math, this folding is blocked. The compiler must emit the log call to preserve the trap that the original code would trigger.

If the GCC manual feels too high-level, these resources dive deeper with context and examples:

• GCC Internals Manual: Goes beyond user-facing docs to explain the compiler's decision logic for floating-point optimizations, including exactly how -ftrapping-math interacts with optimization passes.
• Clang/LLVM Documentation: LLVM's language reference and Clang user manual break down fine-grained floating-point options (like the -ffp-model series, which expands on -ftrapping-math's behavior) with concrete code-generation examples.
• 《Writing Efficient Numerical Code》: This book includes chapters dedicated to compiler floating-point optimization behavior, covering GCC, Clang, and other compilers with reproducible code snippets that show how options change output.
• Compiler Explorer (local use): While it's a tool, you can directly compare assembly output for the same code compiled with -ftrapping-math vs -fno-trapping-math—this is the most hands-on way to see exactly which optimizations get blocked or allowed.

内容的提问来源于stack exchange，提问作者A Fog