Intrinsics: Make is_fpclass and arithmetic_fence speculatable

[arsenm]

Summary

Mostly I'm not sure where the right place for the test is. I don't see an obvious test all these intrinsics are speculatable test

[jdoerfert]

llvm/include/llvm/IR/Intrinsics.td

715

The subject line says this is now speculatable but the definition here is not. I'm confused.
Given the description, this "fence" doesn't actually do anything except provide a semi-permeable value pass-through, right? Then I agree this should be speculatable.

763

WillReturn is implied by default, I think

[arsenm]

llvm/include/llvm/IR/Intrinsics.td

715

The math instructions here are wrapped in a let IntrProperties block above. arithmetic_fence picks up willreturn also

[jdoerfert]

LG

llvm/include/llvm/IR/Intrinsics.td

679

I see. WillReturn is also unnecessary here but maybe some non defaults will be added in the future.

[arsenm]

f5e2eb11d8c4f54e26aed442d5262396b4b327a7

llvm/include/llvm/IR/Intrinsics.td

: Intrinsic<[],
       [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty, llvm_i1_ty],
       [IntrWriteMem, IntrArgMemOnly, IntrWillReturn, IntrNoFree, IntrNoCallback,
        NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
        ImmArg<ArgIndex<2>>, ImmArg<ArgIndex<3>>]>;
 
 // FIXME: Add version of these floating point intrinsics which allow non-default
 // rounding modes and FP exception handling.
 
 let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_fma  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                            [LLVMMatchType<0>, LLVMMatchType<0>,
                             LLVMMatchType<0>]>;
   def int_fmuladd : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                               [LLVMMatchType<0>, LLVMMatchType<0>,
                                LLVMMatchType<0>]>;
 
   // These functions do not read memory, but are sensitive to the
let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_ceil  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_trunc : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_rint  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_nearbyint : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_round : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_roundeven    : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_canonicalize : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
                                    [IntrNoMem]>;
+  // Arithmetic fence intrinsic.
+  def int_arithmetic_fence : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
+                                                   [IntrNoMem]>;
 
   def int_lround : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_llround : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_lrint : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_llrint : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
 }
 
 def int_minnum : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],

 }
 
 //===--------------- Floating Point Properties ----------------------------===//
 //
 
 def int_is_fpclass
     : DefaultAttrsIntrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
                             [llvm_anyfloat_ty, llvm_i32_ty],
-                            [IntrNoMem, IntrWillReturn, ImmArg<ArgIndex<1>>]>;
+                            [IntrNoMem, IntrWillReturn, IntrSpeculatable, ImmArg<ArgIndex<1>>]>;
 
 //===--------------- Constrained Floating Point Intrinsics ----------------===//
 //
 
 let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in {
   def int_experimental_constrained_fadd : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
                                                     [ LLVMMatchType<0>,
                                                       LLVMMatchType<0>,

 
 // The pseudoprobe intrinsic works as a place holder to the block it probes.
 // Like the sideeffect intrinsic defined above, this intrinsic is treated by the
 // optimizer as having opaque side effects so that it won't be get rid of or moved
 // out of the block it probes.
 def int_pseudoprobe : DefaultAttrsIntrinsic<[], [llvm_i64_ty, llvm_i64_ty, llvm_i32_ty, llvm_i64_ty],
                                     [IntrInaccessibleMemOnly, IntrWillReturn]>;
 
-// Arithmetic fence intrinsic.
-def int_arithmetic_fence : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>], [IntrNoMem]>;
-
 // Intrinsics to support half precision floating point format
 let IntrProperties = [IntrNoMem, IntrWillReturn] in {
 def int_convert_to_fp16   : DefaultAttrsIntrinsic<[llvm_i16_ty], [llvm_anyfloat_ty]>;
 def int_convert_from_fp16 : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [llvm_i16_ty]>;
 }
 
 // Saturating floating point to integer intrinsics
 let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {

llvm/test/Transforms/SpeculativeExecution/spec-calls.ll

define void @ifThen_call_readnone() {
   br i1 true, label %a, label %b
 a:
   %x = call float @unknown_readnone(float 1.0)
   br label %b
 
 b:
   ret void
 }
+
+; CHECK-LABEL: @ifThen_fpclass(
+; CHECK: %class = call i1 @llvm.is.fpclass.f32(float %x, i32 11)
+; CHECK-NEXT: br i1 true
+define void @ifThen_fpclass(float %x) {
+  br i1 true, label %a, label %b
+
+a:
+  %class = call i1 @llvm.is.fpclass.f32(float %x, i32 11)
+  br label %b
+
+b:
+  ret void
+}
+
+; CHECK-LABEL: @ifThen_arithmetic_fence(
+; CHECK: %class = call i1 @llvm.is.fpclass.f32(float %x, i32 11)
+; CHECK-NEXT: br i1 true
+define void @ifThen_arithmetic_fence(float %x) {
+  br i1 true, label %a, label %b
+
+a:
+  %canon = call float @llvm.arithmetic.fence.f32(float %x)
+  br label %b
+
+b:
+  ret void
+}
+
+declare i1 @llvm.is.fpclass.f32(float, i32)
+declare float @llvm.arithmetic.fence.f32(float)