[SPIR] Add support for __arithmetic_fence builtin for SPIR target.

[zahiraam]

Summary

__arithmetic_fence enforces ordering on expression evaluation when fast math is enabled.
In fast math mode some floating-point optimizations are performed such as reassociation and distribution.

For example, the compiler may transform (a+b)+c into a+(b+c). Although these two expressions are
equivalent in integer arithmetic, they may not be in floating-point arithmetic. The builtin tells the compiler that
the expression in parenthesis can’t be re-associated or distributed.
__arithmetic_fence(a+b)+c is not equivalent to a+(b+c).

This patch adds the support of the builtin to SPIR target.

[bader]

"[SPIR-V] Add support for arithmetic_fence builtin for SYCL targets." -> "[SPIR] Add support for arithmetic_fence builtin for SPIR target."

clang/test/CodeGen/arithmetic-fence-builtin.c

16

74

What is different for SPIR target here?

clang/test/Sema/arithmetic-fence-builtin.c

5

[bader]

clang/test/CodeGen/arithmetic-fence-builtin.c

74

Why is this check removed for SPIR target?

[zahiraam]

clang/test/CodeGen/arithmetic-fence-builtin.c

74

The RUN at line 16 with -DFAST would generate a warning: "#pragma float_control is not supported on this target". That's why I separated that check from the others.

74

Added.

[bader]

LGTM. Thanks!

[zahiraam]

In D142583#4083251, @bader wrote:

LGTM. Thanks!

Thanks.

clang/lib/Basic/Targets/SPIR.h

public:
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   bool hasFeature(StringRef Feature) const override {
     return Feature == "spir";
   }
+
+  bool checkArithmeticFenceSupported() const override { return true; }
 };
 
 class LLVM_LIBRARY_VISIBILITY SPIR32TargetInfo : public SPIRTargetInfo {
 public:
   SPIR32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : SPIRTargetInfo(Triple, Opts) {
     assert(Triple.getArch() == llvm::Triple::spir &&
            "Invalid architecture for 32-bit SPIR.");

clang/test/CodeGen/arithmetic-fence-builtin.c

 // Test with fast math
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm -DFAST \
 // RUN: -mreassociate \
 // RUN: -o - %s | FileCheck --check-prefixes CHECK,CHECKFAST,CHECKNP %s
 //
 // Test with fast math and fprotect-parens
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm -DFAST \
 // RUN: -mreassociate -fprotect-parens -ffp-contract=on\
 // RUN: -o - %s | FileCheck --check-prefixes CHECK,CHECKFAST,CHECKPP %s
 //
 // Test without fast math: llvm intrinsic not created
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm -fprotect-parens\
 // RUN: -o - %s | FileCheck --implicit-check-not="llvm.arithmetic.fence" %s
 //
+// Test with fast math on spir target
+// RUN: %clang_cc1 -triple spir64  -emit-llvm -DFAST \
+// RUN: -mreassociate -o - %s \
+// RUN: | FileCheck --check-prefixes CHECK,CHECKFAST,CHECKNP %s
+//
+
 int v;
 int addit(float a, float b) {
   // CHECK: define {{.*}}@addit(float noundef %a, float noundef %b) #0 {
   _Complex double cd, cd1;
   cd = __arithmetic_fence(cd1);
   // CHECKFAST: call{{.*}} double @llvm.arithmetic.fence.f64({{.*}}real)
   // CHECKFAST: call{{.*}} double @llvm.arithmetic.fence.f64({{.*}}imag)
   // Vector should be supported.
int addit1(int a, int b) {
   // CHECK: define {{.*}}@addit1(i32 noundef %a, i32 noundef %b{{.*}}
   v = (a + b);
   // CHECK-NOT: call{{.*}} float @llvm.arithmetic.fence.int(float noundef %add)
   return 0;
 }
 #ifdef FAST
 #pragma float_control(precise, on)
 int subit(float a, float b, float *fp) {
   // CHECKFAST: define {{.*}}@subit(float noundef %a, float noundef %b{{.*}}
   *fp = __arithmetic_fence(a - b);
   *fp = (a + b);
   // CHECK-NOT: call{{.*}} float @llvm.arithmetic.fence.f32(float noundef %add)
   return 0;
 }
 #endif

clang/test/Sema/arithmetic-fence-builtin.c

 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm -o - -verify -x c++ %s
 // RUN: %clang_cc1 -triple ppc64le -DPPC     -emit-llvm -o - -verify -x c++ %s
 // RUN: not %clang_cc1 -triple ppc64le -DPPC     -emit-llvm -o - -x c++ %s \
 // RUN:            -fprotect-parens 2>&1 | FileCheck -check-prefix=PPC %s
+// RUN: %clang_cc1 -triple spir64 -emit-llvm -o - -verify -x c++ %s
 #ifndef PPC
 int v;
 template <typename T> T addT(T a, T b) {
   T *q = __arithmetic_fence(&a);
   // expected-error@-1 {{invalid operand of type 'float *' where floating, complex or a vector of such types is required}}
   // expected-error@-2 {{invalid operand of type 'int *' where floating, complex or a vector of such types is required}}
   return __arithmetic_fence(a + b);
   // expected-error@-1 {{invalid operand of type 'int' where floating, complex or a vector of such types is required}}