Change default to JIT without fma (AcademySoftwareFoundation#2076)

The ShadingSystem option "llvm_jit_fma" seems to advertise that it
switches between no fused multiply-add (the default, 0), versus
allowing fma to be generated in the JIT.

The underlying LLVM option is actually a 3-way switch about how to
utilized fused ops: Strict (no fused ops), Standard (allow fma but not
other fused ops), or Fast (allow other fused ops when it will speed
things up). Aside: "standard" is really confusing, as one might think
it means original standard IEEE 754 definitions that lacked fma.

These are not the same! We were using llvm_jit_fma to switch between
Standard and Fast, but upon closer examination, we now believe that it
should control a switch between Strict and Standard, and Strict should
be the default.

This seems to directly change the pesky render-microfacet test, which
has always seemed to have an unusual sensitivity to the specific
processor. Hopefully, users will find that across the board, it leads
to their renderers having fewer minor pixel differences from one
platform to another.

Signed-off-by: Larry Gritz <lg@larrygritz.com>

Author: lgritz

src/liboslexec/llvm_util.cpp

@@ -1529,9 +1529,15 @@ LLVM_Util::make_jit_execengine(std::string* err, TargetISA requestedISA,
 
     llvm::TargetOptions options;
     // Enables FMA's in IR generation.
-    // However cpu feature set may or may not support FMA's independently
-    options.AllowFPOpFusion = jit_fma() ? llvm::FPOpFusion::Fast
-                                        : llvm::FPOpFusion::Standard;
+    // However cpu feature set may or may not support FMA's independently.
+    // Note: This is confusingly named, LLVM's FPOpFution choices are Strict
+    // (no fma used), Standard (fma used for actual fma circumstances), and
+    // Fast (fused ops beyond just fma's, any time it thinks it will be
+    // faster). Since we call the option "jit_fma", we interpret that as
+    // switching between Strict and Standard. We will need some other control
+    // if we ever want full "Fast" mode.
+    options.AllowFPOpFusion = jit_fma() ? llvm::FPOpFusion::Standard
+                                        : llvm::FPOpFusion::Strict;
     // Unfortunately enabling UnsafeFPMath allows reciprocals, which we don't want for divides
     // To match results for existing unit tests we might need to disable UnsafeFPMath
     // TODO: investigate if reciprocals can be disabled by other means.