[clang] Fix missing contract flag in sqrt intrinsic

[yaxunl]

Summary

The fp options specified through pragma are already encoded in Expr.

This patch takes the same approach used by clang codegen to emit fastmath flags for fadd insts, basically use RAII to set the current fastmath flags in IRBuilder, which is then used to emit sqrt intrinsic.

Fix: https://github.com/llvm/llvm-project/issues/64653

[rjmccall]

clang/lib/CodeGen/CGBuiltin.cpp

499–500

Is this existing condition not good enough, and why?

[arsenm]

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

18

Should leave the existing test function alone and add a new one. Also can you test some cases with nested different values

[arsenm]

clang/lib/CodeGen/CGBuiltin.cpp

499–500

It's only in the strictfp branch for some reason, I don't think both would be needed

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

8

Should also check constrained run line

[yaxunl]

clang/lib/CodeGen/CGBuiltin.cpp

499–500

It seems I just need to move the RAII out of that condition.

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

8

will do

18

pragma clang fp cannot be used inside compound statements. It is only allowed in either function scope or at the beginning of a compound statement. Essentially, it can only enable/disable contracting at a granularity of the function level. I can add a test for enabling/disabling it in different functions.

[yaxunl]

revised by comments

[arsenm]

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

94

This isn't demonstrating the strict support, probably need to add the pragma fenv_access for the -fexperimental-strict-floating-point run line

[rjmccall]

Code change LGTM; I'll let you hash out the test feedback.

[yaxunl]

fix test for strict fp

clang/lib/CodeGen/CGBuiltin.cpp

 // Emit a simple mangled intrinsic that has 1 argument and a return type
 // matching the argument type. Depending on mode, this may be a constrained
 // floating-point intrinsic.
 static Value *emitUnaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
                                 const CallExpr *E, unsigned IntrinsicID,
                                 unsigned ConstrainedIntrinsicID) {
   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
 
-  if (CGF.Builder.getIsFPConstrained()) {
-    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
+  if (CGF.Builder.getIsFPConstrained()) {
     Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());
     return CGF.Builder.CreateConstrainedFPCall(F, { Src0 });
   } else {
     Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
     return CGF.Builder.CreateCall(F, Src0);
   }
 }
 
 // Emit an intrinsic that has 2 operands of the same type as its result.

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

-// RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -O3 -triple %itanium_abi_triple \
+// RUN:   -emit-llvm -o - %s \
+// RUN:   | FileCheck -check-prefixes=COMMON,CHECK %s
+// RUN: %clang_cc1 -fexperimental-strict-floating-point \
+// RUN:   -ffp-exception-behavior=strict -O3 \
+// RUN:   -triple %itanium_abi_triple -emit-llvm -o - %s \
+// RUN:   | FileCheck -check-prefixes=COMMON,STRICT %s
 
 // Is FP_CONTRACT honored in a simple case?
 float fp_contract_1(float a, float b, float c) {
-// CHECK: _Z13fp_contract_1fff
+// COMMON: _Z13fp_contract_1fff
 // CHECK: %[[M:.+]] = fmul contract float %a, %b
 // CHECK-NEXT: fadd contract float %[[M]], %c
+// STRICT: %[[M:.+]] = tail call contract float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+// STRICT-NEXT: tail call contract float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
+
 #pragma clang fp contract(fast)
   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
+  // COMMON: _Z13fp_contract_2fff
   // CHECK: %[[M:.+]] = fmul float %a, %b
   // CHECK-NEXT: fadd float %[[M]], %c
+  // STRICT: %[[M:.+]] = tail call float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // STRICT-NEXT: tail call float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
   {
 #pragma clang fp contract(fast)
   }
   return a * b + c;
 }
 
 // Does FP_CONTRACT survive template instantiation?
 class Foo {};
 Foo operator+(Foo, Foo);
 
 template <typename T>
 T template_muladd(T a, T b, T c) {
 #pragma clang fp contract(fast)
   return a * b + c;
 }
 
 float fp_contract_3(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_3fff
+  // COMMON: _Z13fp_contract_3fff
   // CHECK: %[[M:.+]] = fmul contract float %a, %b
   // CHECK-NEXT: fadd contract float %[[M]], %c
+  // STRICT: %[[M:.+]] = tail call contract float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // STRICT-NEXT: tail call contract float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
   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(fast)
     return a * b + c;
   }
 };
 
 template class fp_contract_4<int>;
-// CHECK: _ZN13fp_contract_4IiE6methodEfff
+// COMMON: _ZN13fp_contract_4IiE6methodEfff
 // CHECK: %[[M:.+]] = fmul contract float %a, %b
 // CHECK-NEXT: fadd contract float %[[M]], %c
+// STRICT: %[[M:.+]] = tail call contract float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+// STRICT-NEXT: tail call contract float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
 
 // Check file-scoped FP_CONTRACT
 #pragma clang fp contract(fast)
 float fp_contract_5(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_5fff
+  // COMMON: _Z13fp_contract_5fff
   // CHECK: %[[M:.+]] = fmul contract float %a, %b
   // CHECK-NEXT: fadd contract float %[[M]], %c
+  // STRICT: %[[M:.+]] = tail call contract float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // STRICT-NEXT: tail call contract float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
   return a * b + c;
 }
 
 // Verify that we can handle multiple flags on the same pragma
 #pragma clang fp contract(fast) contract(off)
 float fp_contract_6(float a, float b, float c) {
-  // CHECK: _Z13fp_contract_6fff
+  // COMMON: _Z13fp_contract_6fff
   // CHECK: %[[M:.+]] = fmul float %a, %b
   // CHECK-NEXT: fadd float %[[M]], %c
+  // STRICT: %[[M:.+]] = tail call float @llvm.experimental.constrained.fmul.f32(float %a, float %b, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  // STRICT-NEXT: tail call float @llvm.experimental.constrained.fadd.f32(float %[[M]], float %c, metadata !"round.tonearest", metadata !"fpexcept.strict")
   return a * b + c;
 }
+
+
+#pragma clang fp contract(fast)
+float fp_contract_7(float a) {
+// COMMON: _Z13fp_contract_7f
+// CHECK: tail call contract float @llvm.sqrt.f32(float %a)
+// STRICT: tail call contract float @llvm.experimental.constrained.sqrt.f32(float %a, metadata !"round.tonearest", metadata !"fpexcept.strict")
+  return __builtin_sqrtf(a);
+}
+
+float fp_contract_8(float a) {
+// COMMON: _Z13fp_contract_8f
+// CHECK: tail call float @llvm.sqrt.f32(float %a)
+// STRICT: tail call float @llvm.experimental.constrained.sqrt.f32(float %a, metadata !"round.tonearest", metadata !"fpexcept.strict")
+#pragma clang fp contract(off)
+  return __builtin_sqrtf(a);
+}