[OpenCL] Prevent fused mul and add by default

[Anastasia]

Summary

Currently, clang will generate fused operation fmuladd for expressions like a*b+c. However, I can't find anything in the spec that explains this behavior. But clang was doing this for almost 10 years....

I looked at:
s6.13.2 where it details fp conract pragma:

// on-off-switch is one of ON, OFF, or DEFAULT.
// The DEFAULT value is ON.
#pragma OPENCL FP_CONTRACT on-off-switch

The default behavior here refers to the default value of the pragma when used in the source code.

s7.4 table 38

x * y + z
Implemented either as a correctly rounded fma or as a multiply and an add both of which are correctly rounded.

This table described behavior when -cl-unsafe-math-optimizations flag is passed.

I can't find anything else that would justify allowing fused operations, therefore I assume this is not safe to do and can cause issues on some applications/targets

[rjmccall]

I think "the default value is on" is meant to imply that contraction is allowed by default, not that you can write the pragma without an on-off-switch and it means "on".

FWIW, that would be consistent with C, which also enables contraction by default.

[sepavloff]

Contraction is just an optimization technique. Unless a user explicitly requests strict FP semantics, contraction does not break C++ semantics.

[arsenm]

I think the current handling is correct. As you said, the specified default is FP_CONTRACT ON. The description of the mad function in the table is unrelated, since that's the definition and won't change based on the pragma.

clang/lib/Frontend/CompilerInvocation.cpp

#endif
   else if (LangStd == LangStandard::lang_openclcpp)
     Opts.OpenCLCPlusPlusVersion = 100;
 
   // OpenCL has some additional defaults.
   if (Opts.OpenCL) {
     Opts.AltiVec = 0;
     Opts.ZVector = 0;
     Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::None);
-    Opts.setDefaultFPContractMode(LangOptions::FPM_On);
     Opts.NativeHalfType = 1;
     Opts.NativeHalfArgsAndReturns = 1;
     Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
 
     // Include default header file for OpenCL.
     if (Opts.IncludeDefaultHeader) {
       if (Opts.DeclareOpenCLBuiltins) {
         // Only include base header file for builtin types and constants.

clang/test/CodeGenOpenCL/relaxed-fpmath.cl

float spscalardiv(float a, float b) {
   // FINITE: fdiv nnan ninf float
   // UNSAFE: fdiv nnan nsz float
   // MAD: fdiv contract float
   // NOSIGNED: fdiv nsz float
   return a / b;
 }
 
 float fused_mad(float a, float b, float c) {
-  // NORMAL: tail call float @llvm.fmuladd.f32(float %a, float %b, float %c)
+  // NORMAL: fmul float
+  // NORMAL: fadd float
   // FAST: fmul fast float
   // FAST: fadd fast float
   // MAD: fmul contract float
   // MAD: fadd contract float
   return a*b+c;
 }
 
 float fused_mad_accross_stmts(float a, float b, float c) {

clang/test/CodeGenOpenCL/single-precision-constant.cl

 // RUN: %clang_cc1 %s -cl-single-precision-constant -emit-llvm -o - | FileCheck %s
 
 float fn(float f) {
-  // CHECK: tail call float @llvm.fmuladd.f32(float %f, float 2.000000e+00, float 1.000000e+00)
+  // CHECK: fmul float %f, 2.000000e+00
+  // CHECK: fadd float %mul, 1.000000e+00
   return f*2. + 1.;
 }