FastMathFlags.allowContract should be init from FPFeatures.allowFPContractAcrossStatement

[mibintc]

Summary

Previously, the IRBuilder.FMF.allowContract was initialized to true if either (ffp-contract=fast or ffp-contract=on) ; with this patch that bit will only be set if ffp-contract=fast. This problem was pointed out by michele.scandale in a reply to https://reviews.llvm.org/D72841

[mibintc]

added some inline explanation

clang/lib/Frontend/CompilerInvocation.cpp

2948

I changed this because the FAST version of this test clang/test/CodeGenOpenCL/relaxed-fpmath.cl wants the 'fast' attribute on the instruction dump. All the LLVM FMF bits must be set for the fast attribute print. By default, the value for OpenCL is ffp-contract=on

clang/lib/Sema/SemaAttr.cpp

460 ↗

(On Diff #263826)

When i was adding a test, I realized that pragma float_control(push) then pop wasn't working as expected. If the stack is empty, which is most of the time, first need to push the current fp features onto the stack so they can be restored at the pop

clang/test/CodeGen/constrained-math-builtins.c

157

most of the test changes here are just a revert of the test changes from the original patch for float_control

[rjmccall]

clang/lib/Frontend/CompilerInvocation.cpp

2948

Is there an overall behavior change for OpenCL across these patches?

clang/lib/Sema/SemaAttr.cpp

460 ↗

(On Diff #263826)

It seems that the way PragmaStack is supposed to be used is that we're supposed to be using its CurrentValue instead of having a separate CurFPFeatures. But mostly it looks like there's a lot of functionality associated with PragmaStack that we aren't using at all because this is a substantially simpler mode; we could really just be using a SmallVector<FPOptions, 2>.

Anyway, I guess this fix works, although it should be done in a separate patch.

[mibintc]

clang/lib/Frontend/CompilerInvocation.cpp

2948

I think the answer to your question is no. Here is more details: OpenCL sets the default behavior to ffp-contract=on. In https://reviews.llvm.org/D72841 I added the function UpdateFastMathFlags, that function set the llvm FMF.allowContract bit to be ( ffp-contract=on or ffp-contract=fast). This patch just drops the check on ffp-contract=on. I didn't wind back to see how the llvm fast attribute was being set for this [opencl] test case originally.

[rjmccall]

clang/lib/Frontend/CompilerInvocation.cpp

2948

Well, to what extent are there (including this patch) overall test changes for the OpenCL tests, and what are tthey?

[mibintc]

clang/lib/Frontend/CompilerInvocation.cpp

2948

In the #pragma float_control patch https://reviews.llvm.org/D72841, I changed 2 CodeGen/OpenCL tests: relaxed-fp-math.cl in the non-FAST cases to show the contract bit. Also 1 line in single-precision-constant.cl for the same reason, to show the contract bit. This patch undoes those test changes. I'll do more investigation to understand why the fast bit isn't being set in the FAST case in relaxed-fpmath.cl without the change to CompilerInovcaton

clang/lib/Sema/SemaAttr.cpp

460 ↗

(On Diff #263826)

I'll submit it in a separate patch.

[mibintc]

reply about the incorrect setting of 'fast' during OpenCL compilation with option -cl-fast-relaxed-math

clang/lib/Frontend/CompilerInvocation.cpp

2948

Prior to the patch for #pragma float_control, the llvm.FastMathFlags was initialized from LangArgs.FastMath in the CodeGenFunction constructor approximately line 74, and the FMF values in IRBuilder were never changed--For the test clang/test/CodeGenOpenCL/relaxed-fpmath.cl with option -cl-fast-relaxed-math. (In ParseLangArgs, Opts.FastMath = Args.hasArg(OPT_ffast_math) || Args.hasArg(OPT_cl_fast_relaxed_math)) If FastMath is on, then all the llvm.FMF flags are set.

The #pragma float_control patch does change the IRBuilder settings in the course of visiting the Expr nodes, using the information in the Expr nodes, but the initial setting of FPFeatures from the command line overlooked the fact that FastMath, and therefore ffp-contract=fast, is enabled.

[michele.scandale]

clang/lib/Frontend/CompilerInvocation.cpp

2948

Prior to D72841 compiling something with -ffast-math -ffp-contract={on,off} was still producing fast as fast-math flags on the instructions for the same reason.
The clang driver does not consider the contraction mode for passing -ffast-math to CC1, which is consistent with the GCC behavior (I checked if the __FAST_MATH__ is defined if I compile with -ffast-math -ffp-contract=off).
According to this, the code in CodeGenFunction:

if (LangOpts.FastMath)
  FMF.setFast();

is not correct.

The OpenCL option -cl-fast-relaxed-math should be equivalent to -ffast-math for the user. I don't know what the interaction between -cl-fast-relaxed-math and -ffp-contract={on, off,fast}.

If we need to keep -cl-fast-relaxed-math a CC1 option, I guess the following might work:

if (Args.hasArg(OPTS_cl_fast_relaxed_math) && !Arg.hasArg(OPT_ffp_contractEQ))
  Opts.setDefaultFPContractMode)LangOptions::FPM_Fast);

[rjmccall]

clang/lib/Frontend/CompilerInvocation.cpp

2948

Okay, thanks for the investigation, I agree that that all makes sense. I'm not sure what it would mean to enable fast math but disable contraction — that combination doesn't seem useful.

I'm fine with going forward with the OpenCL changes as they are, but you might want to specifically reach out to the OpenCL people and let them know what's going on.

[mibintc]

This is the same as the previous patch, except I removed the fix for pragma push-pop that John said should be committed separately

[mibintc]

clang/lib/Frontend/CompilerInvocation.cpp

2948

@arsenm Matt, I'm making this change to CompilerInvocation to fix a bug that was introduced by https://reviews.llvm.org/D72841 I see that you contribute to OpenCL will you please let interested folks know about this change?
D72841 erroneously set the llvm.FMF.contract bit to true whether the contraction status was "allow contraction across statements" or "allow contraction within statements". This patch corrects that error to set llvm.FMF.contract bit only when contraction status is "allow contraction across statements". D72841 mis-captured the initial contraction status, this patch corrects that by checking the specific OpenCL option OPTS_cl_fast_relaxed_math.
D72841 made a couple changes to OpenCL tests about the 'contract' flag in the IR, this patch undoes those test changes.

[mibintc]

clang/lib/Frontend/CompilerInvocation.cpp

2948

@Anastasia Adding Anastasia about this issue

[Anastasia]

clang/lib/Frontend/CompilerInvocation.cpp

2948

This change seems reasonable as it indeed restores the correct OpenCL behavior. Thanks for looking into this!

I think we might also be able to set contract on -cl-mad-enable, but this can be done as a separate follow up improvement patch if we decide this is the right route forward.

[michele.scandale]

This looks good to me. @rjmccall do you have any more feedback?

[rjmccall]

No, go ahead.

clang/lib/CodeGen/CGExprScalar.cpp

 static void updateFastMathFlags(llvm::FastMathFlags &FMF,
                                 FPOptions FPFeatures) {
   FMF.setAllowReassoc(FPFeatures.allowAssociativeMath());
   FMF.setNoNaNs(FPFeatures.noHonorNaNs());
   FMF.setNoInfs(FPFeatures.noHonorInfs());
   FMF.setNoSignedZeros(FPFeatures.noSignedZeros());
   FMF.setAllowReciprocal(FPFeatures.allowReciprocalMath());
   FMF.setApproxFunc(FPFeatures.allowApproximateFunctions());
-  FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement() ||
-                       FPFeatures.allowFPContractWithinStatement());
+  FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
 }
 
 /// Propagate fast-math flags from \p Op to the instruction in \p V.
 static Value *propagateFMFlags(Value *V, const BinOpInfo &Op) {
   if (auto *I = dyn_cast<llvm::Instruction>(V)) {
     llvm::FastMathFlags FMF = I->getFastMathFlags();
     updateFastMathFlags(FMF, Op.FPFeatures);
     I->setFastMathFlags(FMF);

clang/lib/Frontend/CompilerInvocation.cpp

+      Args.hasFlag(OPT_frecovery_ast_type, OPT_fno_recovery_ast_type, false);
   Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
   Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
                         || Args.hasArg(OPT_fdump_record_layouts);
   Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
   Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
   Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
   Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
   Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
+  if (Opts.FastRelaxedMath)
+    Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
   Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
   Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
   Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
   Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
   Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
   Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
   Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
   Opts.ModuleName = std::string(Args.getLastArgValue(OPT_fmodule_name_EQ));

clang/test/CodeGen/constrained-math-builtins.c

 };
 
 #pragma STDC FP_CONTRACT ON
 void bar(float f) {
   f * f + f;
   (double)f * f - f;
   (long double)-f * f + f;
 
-  // CHECK: call contract float @llvm.experimental.constrained.fmuladd.f32
+  // CHECK: call float @llvm.experimental.constrained.fmuladd.f32
   // CHECK: fneg
-  // CHECK: call contract double @llvm.experimental.constrained.fmuladd.f64
+  // CHECK: call double @llvm.experimental.constrained.fmuladd.f64
   // CHECK: fneg
-  // CHECK: call contract x86_fp80 @llvm.experimental.constrained.fmuladd.f80
+  // CHECK: call x86_fp80 @llvm.experimental.constrained.fmuladd.f80
 };

clang/test/CodeGen/fp-contract-on-pragma.cpp

 // RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
 
 // Is FP_CONTRACT honored in a simple case?
 float fp_contract_1(float a, float b, float c) {
 // CHECK: _Z13fp_contract_1fff
-// CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
 #pragma clang fp contract(on)
   return a * b + c;
 }
 
 // Is FP_CONTRACT state cleared on exiting compound statements?
 float fp_contract_2(float a, float b, float c) {
   // CHECK: _Z13fp_contract_2fff
   // CHECK: %[[M:.+]] = fmul float %a, %b

 template <typename T>
 T template_muladd(T a, T b, T c) {
 #pragma clang fp contract(on)
   return a * b + c;
 }
 
 float fp_contract_3(float a, float b, float c) {
   // CHECK: _Z13fp_contract_3fff
-  // CHECK: tail call contract float @llvm.fmuladd
+  // CHECK: tail call float @llvm.fmuladd
   return template_muladd<float>(a, b, c);
 }
 
 template <typename T>
 class fp_contract_4 {
   float method(float a, float b, float c) {
 #pragma clang fp contract(on)
     return a * b + c;
   }
 };
 
 template class fp_contract_4<int>;
 // CHECK: _ZN13fp_contract_4IiE6methodEfff
-// CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
 
 // Check file-scoped FP_CONTRACT
 #pragma clang fp contract(on)
 float fp_contract_5(float a, float b, float c) {
   // CHECK: _Z13fp_contract_5fff
-  // CHECK: tail call contract float @llvm.fmuladd
+  // CHECK: tail call float @llvm.fmuladd
   return a * b + c;
 }
 
 #pragma clang fp contract(off)
 float fp_contract_6(float a, float b, float c) {
   // CHECK: _Z13fp_contract_6fff
   // CHECK: %[[M:.+]] = fmul float %a, %b
   // CHECK-NEXT: fadd float %[[M]], %c
   return a * b + c;
 }
 
 // If the multiply has multiple uses, don't produce fmuladd.
 // This used to assert (PR25719):
 // https://llvm.org/bugs/show_bug.cgi?id=25719
 
 float fp_contract_7(float a, float b, float c) {
 // CHECK: _Z13fp_contract_7fff
-// CHECK:  %[[M:.+]] = fmul contract float %b, 2.000000e+00
-// CHECK-NEXT: fsub contract float %[[M]], %c
+// CHECK:  %[[M:.+]] = fmul float %b, 2.000000e+00
+// CHECK-NEXT: fsub float %[[M]], %c
 #pragma clang fp contract(on)
   return (a = 2 * b) - c;
 }

clang/test/CodeGen/fp-contract-pragma.cpp

 // RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
 
 // Is FP_CONTRACT honored in a simple case?
 float fp_contract_1(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_1fff
-  // CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return a * b + c;
 }
 
 // Is FP_CONTRACT state cleared on exiting compound statements?
 float fp_contract_2(float a, float b, float c) {
 // CHECK: _Z13fp_contract_2fff
 // CHECK: %[[M:.+]] = fmul float %a, %b
 // CHECK-NEXT: fadd float %[[M]], %c

 
 template <typename T>
 T template_muladd(T a, T b, T c) {
   #pragma STDC FP_CONTRACT ON
   return a * b + c;
 }
 
 float fp_contract_3(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_3fff
-  // CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
   return template_muladd<float>(a, b, c);
 }
 
 template<typename T> class fp_contract_4 {
   float method(float a, float b, float c) {
     #pragma STDC FP_CONTRACT ON
     return a * b + c;
   }
 };
 
 template class fp_contract_4<int>;
 // CHECK: _ZN13fp_contract_4IiE6methodEfff
-// CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
 
 // Check file-scoped FP_CONTRACT
 #pragma STDC FP_CONTRACT ON
 float fp_contract_5(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_5fff
-  // CHECK: tail call contract float @llvm.fmuladd
+// CHECK: tail call float @llvm.fmuladd
   return a * b + c;
 }
 
 #pragma STDC FP_CONTRACT OFF
 float fp_contract_6(float a, float b, float c) {
 // CHECK: _Z13fp_contract_6fff
 // CHECK: %[[M:.+]] = fmul float %a, %b
 // CHECK-NEXT: fadd float %[[M]], %c
   return a * b + c;
 }
 
 // If the multiply has multiple uses, don't produce fmuladd.
 // This used to assert (PR25719):
 // https://llvm.org/bugs/show_bug.cgi?id=25719
 
 float fp_contract_7(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_7fff
-  // CHECK:  %[[M:.+]] = fmul contract float %b, 2.000000e+00
-  // CHECK-NEXT: fsub contract float %[[M]], %c
+// CHECK:  %[[M:.+]] = fmul float %b, 2.000000e+00
+// CHECK-NEXT: fsub float %[[M]], %c
   #pragma STDC FP_CONTRACT ON
   return (a = 2 * b) - c;
 }
 
 float fp_contract_8(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_8fff
-  // CHECK: fneg contract float %c
-  // CHECK: tail call contract float @llvm.fmuladd
+// CHECK: fneg float %c
+// CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return a * b - c;
 }
 
 float fp_contract_9(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_9fff
-  // CHECK: fneg contract float %a
-  // CHECK: tail call contract float @llvm.fmuladd
+// CHECK: fneg float %a
+// CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return c - a * b;
 }

clang/test/CodeGen/fp-floatcontrol-class.cpp

 // RUN: %clang_cc1 -ffp-contract=on -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -ffp-contract=on -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s
 // Verify that float_control does not pertain to initializer expressions
 
 float y();
 float z();
 #pragma float_control(except, on)
 class ON {
   float w = 2 + y() * z();
   // CHECK-LABEL: define {{.*}} @_ZN2ONC2Ev{{.*}}
-  //CHECK: call contract float {{.*}}llvm.fmuladd
+  //CHECK: call float {{.*}}llvm.fmuladd
 };
 ON on;
 #pragma float_control(except, off)
 class OFF {
   float w = 2 + y() * z();
   // CHECK-LABEL: define {{.*}} @_ZN3OFFC2Ev{{.*}}
-  //CHECK: call contract float {{.*}}llvm.fmuladd
+  //CHECK: call float {{.*}}llvm.fmuladd
 };
 OFF off;

clang/test/CodeGen/fp-floatcontrol-pragma.cpp

//CHECK-NS: llvm.experimental.constrained.fdiv{{.*}}
   return zero;
 }
 
 #pragma float_control(pop)
 float exc_off(double x, float zero) {
 // CHECK-NS: define {{.*}}exc_off{{.*}}
   {} try {
     x = 1.0 / zero; /* division by zero, the result unused */
-//CHECK-NS: fdiv contract double
+//CHECK-NS: fdiv double
   } catch (...) {}
   return zero;
 }
 
 namespace fc_template_namespace {
 #pragma float_control(except, on, push)
 template <class T>
 T exc_on(double x, T zero) {

clang/test/CodeGen/fp-floatcontrol-stack.cpp

 // RUN: %clang_cc1 -triple x86_64-linux-gnu -ffp-contract=on -DDEFAULT=1 -emit-llvm -o - %s | FileCheck --check-prefix=CHECK-DDEFAULT %s
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -ffp-contract=on -DEBSTRICT=1 -ffp-exception-behavior=strict -emit-llvm -o - %s | FileCheck --check-prefix=CHECK-DEBSTRICT %s
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -DFAST=1 -ffast-math -ffp-contract=fast -emit-llvm -o - %s | FileCheck --check-prefix=CHECK-FAST %s
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -ffp-contract=on -DNOHONOR=1 -menable-no-infs -menable-no-nans -emit-llvm -o - %s | FileCheck --check-prefix=CHECK-NOHONOR %s
 
 #define FUN(n) \
   (float z) { return n * z + n; }
 
 float fun_default FUN(1)
 //CHECK-LABEL: define {{.*}} @_Z11fun_defaultf{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: call contract float @llvm.fmuladd{{.*}}
+//CHECK-DDEFAULT: call float @llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
 // Note that backend wants constrained intrinsics used
 // throughout the function if they are needed anywhere in the function.
 // In that case, operations are built with constrained intrinsics operator
 // but using default settings for exception behavior and rounding mode.
 //CHECK-DEBSTRICT: llvm.experimental.constrained.fmul{{.*}}tonearest{{.*}}strict
 #endif

 //CHECK-LABEL: define {{.*}} @_Z6exc_onf{{.*}}
 #if DEFAULT
 //CHECK-DDEFAULT: llvm.experimental.constrained.fmul{{.*}}
 #endif
 #if EBSTRICT
 //CHECK-DEBSTRICT: llvm.experimental.constrained.fmuladd{{.*}}tonearest{{.*}}strict
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: nnan ninf contract float {{.*}}llvm.experimental.constrained.fmuladd{{.*}}tonearest{{.*}}strict
+//CHECK-NOHONOR: nnan ninf float {{.*}}llvm.experimental.constrained.fmuladd{{.*}}tonearest{{.*}}strict
 #endif
 #if FAST
 //Not possible to enable float_control(except) in FAST mode.
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 
 #pragma float_control(pop)
         float exc_pop FUN(5)
 //CHECK-LABEL: define {{.*}} @_Z7exc_popf{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: call contract float @llvm.fmuladd{{.*}}
+//CHECK-DDEFAULT: call float @llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
 //CHECK-DEBSTRICT: llvm.experimental.constrained.fmuladd{{.*}}tonearest{{.*}}strict
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: call nnan ninf contract float @llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 
 #pragma float_control(except, off)
             float exc_off FUN(5)
 //CHECK-LABEL: define {{.*}} @_Z7exc_offf{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: call contract float @llvm.fmuladd{{.*}}
+//CHECK-DDEFAULT: call float @llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: call contract float @llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: call float @llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: call nnan ninf contract float @llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 
 #pragma float_control(precise, on, push)
                 float precise_on FUN(3)
 //CHECK-LABEL: define {{.*}} @_Z10precise_onf{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DDEFAULT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
 // If precise is pushed then all fast-math should be off!
-//CHECK-NOHONOR: call contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if FAST
-//CHECK-FAST: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-FAST: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 
 #pragma float_control(pop)
                     float precise_pop FUN(3)
 //CHECK-LABEL: define {{.*}} @_Z11precise_popf{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DDEFAULT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: call nnan ninf contract float @llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 #pragma float_control(precise, off)
                         float precise_off FUN(4)
 //CHECK-LABEL: define {{.*}} @_Z11precise_offf{{.*}}

 
 #pragma float_control(precise, on)
                             float precise_on2 FUN(3)
 //CHECK-LABEL: define {{.*}} @_Z11precise_on2f{{.*}}
 #if DEFAULT
 //CHECK-DDEFAULT: llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
 // fast math should be off, and contract should be on
-//CHECK-NOHONOR: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if FAST
-//CHECK-FAST: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-FAST: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 
 #pragma float_control(push)
                                 float precise_push FUN(3)
 //CHECK-LABEL: define {{.*}} @_Z12precise_pushf{{.*}}
 #if DEFAULT
 //CHECK-DDEFAULT: llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if FAST
-//CHECK-FAST: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-FAST: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 
 #pragma float_control(precise, off)
                                     float precise_off2 FUN(4)
 //CHECK-LABEL: define {{.*}} @_Z12precise_off2f{{.*}}
 #if DEFAULT
 //CHECK-DDEFAULT: fmul fast float
 //CHECK-DDEFAULT: fadd fast float

 
 #pragma float_control(pop)
                                         float precise_pop2 FUN(3)
 //CHECK-LABEL: define {{.*}} @_Z12precise_pop2f{{.*}}
 #if DEFAULT
 //CHECK-DDEFAULT: llvm.fmuladd{{.*}}
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-DEBSTRICT: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 #if FAST
-//CHECK-FAST: contract float {{.*}}llvm.fmuladd{{.*}}
+//CHECK-FAST: float {{.*}}llvm.fmuladd{{.*}}
 #endif
 
 #ifndef FAST
 // Rule: precise must be enabled
 #pragma float_control(except, on)
 #endif
                                             float y();
 class ON {
   // Settings for top level class initializer revert to command line
   // source pragma's do not pertain.
   float z = 2 + y() * 7;
 //CHECK-LABEL: define {{.*}} void @_ZN2ONC2Ev{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: call contract float {{.*}}llvm.fmuladd
+//CHECK-DDEFAULT: call float {{.*}}llvm.fmuladd
 #endif
 #if EBSTRICT
 //Currently, same as default [command line options not considered]
-//CHECK-DEBSTRICT: call contract float {{.*}}llvm.fmuladd
+//CHECK-DEBSTRICT: call float {{.*}}llvm.fmuladd
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: call nnan ninf contract float @llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 };
 ON on;
 #pragma float_control(except, off)
 class OFF {
   float w = 2 + y() * 7;
 //CHECK-LABEL: define {{.*}} void @_ZN3OFFC2Ev{{.*}}
 #if DEFAULT
-//CHECK-DDEFAULT: call contract float {{.*}}llvm.fmuladd
+//CHECK-DDEFAULT: call float {{.*}}llvm.fmuladd
 #endif
 #if EBSTRICT
-//CHECK-DEBSTRICT: call contract float {{.*}}llvm.fmuladd
+//CHECK-DEBSTRICT: call float {{.*}}llvm.fmuladd
 #endif
 #if NOHONOR
-//CHECK-NOHONOR: call nnan ninf contract float @llvm.fmuladd{{.*}}
+//CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 };
 OFF off;

clang/test/CodeGenOpenCL/relaxed-fpmath.cl

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -check-prefix=NORMAL
 // RUN: %clang_cc1 %s -emit-llvm -cl-fast-relaxed-math -o - | FileCheck %s -check-prefix=FAST
 // RUN: %clang_cc1 %s -emit-llvm -cl-finite-math-only -o - | FileCheck %s -check-prefix=FINITE
 // RUN: %clang_cc1 %s -emit-llvm -cl-unsafe-math-optimizations -o - | FileCheck %s -check-prefix=UNSAFE
 // RUN: %clang_cc1 %s -emit-llvm -cl-mad-enable -o - | FileCheck %s -check-prefix=MAD
 // RUN: %clang_cc1 %s -emit-llvm -cl-no-signed-zeros -o - | FileCheck %s -check-prefix=NOSIGNED
 
 float spscalardiv(float a, float b) {
   // CHECK: @spscalardiv(
 
-  // NORMAL: fdiv contract float
+  // NORMAL: fdiv float
   // FAST: fdiv fast float
-  // FINITE: fdiv nnan ninf contract float
-  // UNSAFE: fdiv nnan nsz contract float
-  // MAD: fdiv contract float
-  // NOSIGNED: fdiv nsz contract float
+  // FINITE: fdiv nnan ninf float
+  // UNSAFE: fdiv nnan nsz float
+  // MAD: fdiv float
+  // NOSIGNED: fdiv nsz float
   return a / b;
 }
 // CHECK: attributes
 
 // NORMAL: "less-precise-fpmad"="false"
 // NORMAL: "no-infs-fp-math"="false"
 // NORMAL: "no-nans-fp-math"="false"
 // NORMAL: "no-signed-zeros-fp-math"="false"

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 contract float @llvm.fmuladd.f32(float %f, float 2.000000e+00, float 1.000000e+00)
+  // CHECK: tail call float @llvm.fmuladd.f32(float %f, float 2.000000e+00, float 1.000000e+00)
   return f*2. + 1.;
 }