Implement SPV_INTEL_arithmetic_fence (#1099)

Implement SPV_INTEL_arithmetic_fence

This extension creates support for a __fence keyword to prevent reordering and
reassociating operations.

Spec: intel/llvm#3914

Author: KornevNikita

include/LLVMSPIRVExtensions.inc

@@ -42,3 +42,4 @@ EXT(SPV_INTEL_fpga_invocation_pipelining_attributes)
 EXT(SPV_INTEL_token_type)
 EXT(SPV_INTEL_debug_module)
 EXT(SPV_INTEL_runtime_aligned)
+EXT(SPV_INTEL_arithmetic_fence)

lib/SPIRV/SPIRVReader.cpp

@@ -2805,6 +2805,15 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     return mapValue(
         BV, transArbFloatInst(static_cast<SPIRVInstruction *>(BV), BB, true));
 
+  case OpArithmeticFenceINTEL: {
+    IRBuilder<> Builder(BB);
+    auto *BC = static_cast<SPIRVUnary *>(BV);
+    Type *RetTy = transType(BC->getType());
+    Value *Val = transValue(BC->getOperand(0), F, BB);
+    return mapValue(
+        BV, Builder.CreateIntrinsic(Intrinsic::arithmetic_fence, RetTy, Val));
+  }
+
   default: {
     auto OC = BV->getOpCode();
     if (isSPIRVCmpInstTransToLLVMInst(static_cast<SPIRVInstruction *>(BV))) {

lib/SPIRV/SPIRVWriter.cpp

@@ -2405,6 +2405,7 @@ bool LLVMToSPIRVBase::isKnownIntrinsic(Intrinsic::ID Id) {
   case Intrinsic::invariant_end:
   case Intrinsic::dbg_label:
   case Intrinsic::trap:
+  case Intrinsic::arithmetic_fence:
     return true;
   default:
     // Unknown intrinsics' declarations should always be translated
@@ -3027,6 +3028,16 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
     else
       return transValue(ConstantInt::getFalse(II->getType()), BB, false);
   }
+  case Intrinsic::arithmetic_fence: {
+    SPIRVType *Ty = transType(II->getType());
+    SPIRVValue *Op = transValue(II->getArgOperand(0), BB);
+    if (BM->isAllowedToUseExtension(ExtensionID::SPV_INTEL_arithmetic_fence)) {
+      BM->addCapability(CapabilityFPArithmeticFenceINTEL);
+      BM->addExtension(ExtensionID::SPV_INTEL_arithmetic_fence);
+      return BM->addUnaryInst(OpArithmeticFenceINTEL, Ty, Op, BB);
+    }
+    return Op;
+  }
   default:
     if (BM->isUnknownIntrinsicAllowed(II))
       return BM->addCallInst(

lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -1566,6 +1566,7 @@ _SPIRV_OP(Any)
 _SPIRV_OP(All)
 _SPIRV_OP(BitCount)
 _SPIRV_OP(BitReverse)
+_SPIRV_OP(ArithmeticFenceINTEL)
 #undef _SPIRV_OP
 
 class SPIRVAccessChainBase : public SPIRVInstTemplateBase {

lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

@@ -577,6 +577,7 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
   add(internal::CapabilityRuntimeAlignedAttributeINTEL,
       "RuntimeAlignedAttributeINTEL");
   add(CapabilityMax, "Max");
+  add(internal::CapabilityFPArithmeticFenceINTEL, "FPArithmeticFenceINTEL");
 }
 SPIRV_DEF_NAMEMAP(Capability, SPIRVCapabilityNameMap)
 

lib/SPIRV/libSPIRV/SPIRVOpCodeEnum.h

@@ -537,3 +537,4 @@ _SPIRV_OP(TypeBufferSurfaceINTEL, 6086)
 _SPIRV_OP(TypeStructContinuedINTEL, 6090)
 _SPIRV_OP(ConstantCompositeContinuedINTEL, 6091)
 _SPIRV_OP(SpecConstantCompositeContinuedINTEL, 6092)
+_SPIRV_OP(ArithmeticFenceINTEL, 6144)

lib/SPIRV/libSPIRV/spirv.hpp

@@ -1051,6 +1051,7 @@ enum Capability {
     CapabilityLongConstantCompositeINTEL = 6089,
     CapabilityAtomicFloat16AddEXT = 6095,
     CapabilityDebugInfoModuleINTEL = 6114,
+    CapabilityFPArithmeticFenceINTEL = 6144,
     CapabilityMax = 0x7fffffff,
 };
 
@@ -1793,6 +1794,7 @@ enum Op {
     OpTypeStructContinuedINTEL = 6090,
     OpConstantCompositeContinuedINTEL = 6091,
     OpSpecConstantCompositeContinuedINTEL = 6092,
+    OpArithmeticFenceINTEL = 6145,
     OpMax = 0x7fffffff,
 };
 

lib/SPIRV/libSPIRV/spirv_internal.hpp

@@ -62,6 +62,7 @@ enum InternalCapability {
   ICapFastCompositeINTEL = 6093,
   ICapOptNoneINTEL = 6094,
   ICapTokenTypeINTEL = 6112,
+  ICapFPArithmeticFenceINTEL = 6144
 };
 
 enum InternalFunctionControlMask { IFunctionControlOptNoneINTELMask = 0x10000 };
@@ -114,6 +115,8 @@ constexpr Capability CapabilityTokenTypeINTEL =
     static_cast<Capability>(ICapTokenTypeINTEL);
 constexpr Capability CapabilityRuntimeAlignedAttributeINTEL =
     static_cast<Capability>(ICapRuntimeAlignedAttributeINTEL);
+constexpr Capability CapabilityFPArithmeticFenceINTEL =
+    static_cast<Capability>(ICapFPArithmeticFenceINTEL);
 
 constexpr FunctionControlMask FunctionControlOptNoneINTELMask =
     static_cast<FunctionControlMask>(IFunctionControlOptNoneINTELMask);

test/transcoding/SPV_INTEL_arithmetic_fence/arithmetic_fence.ll

@@ -0,0 +1,43 @@
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_arithmetic_fence -o %t.spv
+; RUN: llvm-spirv %t.spv --to-text -o %t.spt
+; RUN: FileCheck < %t.spt %s --check-prefix=CHECK-SPIRV
+
+; RUN: llvm-spirv -r %t.spv -o %t.rev.bc
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM
+
+; RUN: llvm-spirv %t.bc -o %t.negative.spv
+; RUN: llvm-spirv %t.negative.spv --to-text -o %t.negative.spt
+; RUN: FileCheck < %t.negative.spt %s --check-prefix=CHECK-SPIRV-NEG
+
+; RUN: llvm-spirv -r %t.negative.spv -o %t.negative.rev.bc
+; RUN: llvm-dis < %t.negative.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM-NEG
+
+; CHECK-SPIRV: Capability FPArithmeticFenceINTEL
+; CHECK-SPIRV: Extension "SPV_INTEL_arithmetic_fence"
+; CHECK-SPIRV: Name [[#Res:]] "t"
+; CHECK-SPIRV: TypeFloat [[#ResTy:]] 64
+; CHECK-SPIRV: FAdd [[#ResTy]] [[#Target:]]
+; CHECK-SPIRV: ArithmeticFenceINTEL [[#ResTy]] [[#Res]] [[#Target]]
+
+; CHECK-LLVM: [[#Op:]] = fadd fast double %a, %a
+; CHECK-LLVM: %t =  call double @llvm.arithmetic.fence.f64(double %[[#Op]])
+; CHECK-LLVM: declare double @llvm.arithmetic.fence.f64(double)
+
+; CHECK-SPIRV-NEG-NOT: Capability FPArithmeticFenceINTEL
+; CHECK-SPIRV-NEG-NOT: Extension "SPV_INTEL_arithmetic_fence"
+; CHECK-SPIRV-NEG-NOT: ArithmeticFenceINTEL
+
+; CHECK-LLVM-NEG-NOT: declare double @llvm.arithmetic.fence.f64(double)
+
+target triple = "spir64-unknown-unknown"
+
+define double @f1(double %a) {
+  %1 = fadd fast double %a, %a
+  %t = call double @llvm.arithmetic.fence.f64(double %1)
+  %2 = fadd fast double %a, %a
+  %3 = fadd fast double %t, %2
+  ret double %3
+}
+
+declare double @llvm.arithmetic.fence.f64(double)