[clang] Add __builtin_isfpclass

[sepavloff]

Summary

A new builtin function __builtin_isfpclass is added. It is called as:

__builtin_isfpclass(<floating point value>, <test>)

and returns an integer value, which is non-zero if the floating point
argument falls into one of the classes specified by the second argument,
and zero otherwise. The set of classes is an integer value, where each
value class is represented by a bit. There are ten data classes, as
defined by the IEEE-754 standard, they are represented by bits:

0x0001 (__FPCLASS_SNAN)         - Signaling NaN
0x0002 (__FPCLASS_QNAN)         - Quiet NaN
0x0004 (__FPCLASS_NEGINF)       - Negative infinity
0x0008 (__FPCLASS_NEGNORMAL)    - Negative normal
0x0010 (__FPCLASS_NEGSUBNORMAL) - Negative subnormal
0x0020 (__FPCLASS_NEGZERO)      - Negative zero
0x0040 (__FPCLASS_POSZERO)      - Positive zero
0x0080 (__FPCLASS_POSSUBNORMAL) - Positive subnormal
0x0100 (__FPCLASS_POSNORMAL)    - Positive normal
0x0200 (__FPCLASS_POSINF)       - Positive infinity

They have corresponding builtin macros to facilitate using the builtin
function:

if (__builtin_isfpclass(x, __FPCLASS_NEGZERO | __FPCLASS_POSZERO) {
  // x is any zero.
}

The data class encoding is identical to that used in llvm.is.fpclass
function.

[qiucf]

It's necessary to check range of first argument in SemaChecking.cpp using SemaBuiltinConstantArgRange.

_Bool check_isfpclass_1(float x) { return __builtin_isfpclass(123456, x); } // ICE

int g;
// error: cannot compile this builtin function yet
// there's better diagnostics when 1st argument is not constant
_Bool check_isfpclass_2(float x) { return __builtin_isfpclass(g, x); }

clang/include/clang/Basic/Builtins.def

491

Why these intrinsics' type spec end with dot? I thought they are for vaargs.

[sepavloff]

Add check for test bit mask value

[sepavloff]

In D152351#4402615, @qiucf wrote:

It's necessary to check range of first argument in SemaChecking.cpp using SemaBuiltinConstantArgRange.

_Bool check_isfpclass_1(float x) { return __builtin_isfpclass(123456, x); } // ICE

int g;
// error: cannot compile this builtin function yet
// there's better diagnostics when 1st argument is not constant
_Bool check_isfpclass_2(float x) { return __builtin_isfpclass(g, x); }

Added the check and a test for it. Thanks!

clang/include/clang/Basic/Builtins.def

491

It is a hack to have polymorphic builtin function. The argument . represents one argument but it can be of any type. So no need to have separate functions for every type.

[arsenm]

clang/test/CodeGen/isfpclass.c

2

Use generated checks?

3

Can you also add a half test, also vectors

12

These operands are backwards, the test should be second

clang/test/Sema/builtins.c

383 ↗

(On Diff #529243)

Need a test for non-immediate class mask. Also a negative value

384 ↗

(On Diff #529243)

What happens if you pass complex?

llvm/lib/IR/IRBuilder.cpp

1379

Use IRBuilder::getInt32

[arsenm]

Also should get mentioned in the builtin docs and release notes

[aaron.ballman]

In D152351#4402785, @arsenm wrote:

Also should get mentioned in the builtin docs and release notes

+1, also, should there be named constants for the mask values?

clang/include/clang/Basic/Builtins.def

491

E in the third arguments means it can be constant evaluated in the frontend, but I don't see any code or tests for that.

clang/lib/Sema/SemaChecking.cpp

2776–2778 ↗

(On Diff #529243)

Do we diagnose if the second argument to the call isn't a floating-point value? e.g., __builtin_isfpclass(0x1, some_struct)

clang/test/Sema/builtins.c

384 ↗

(On Diff #529243)

What happens if you pass a non-float second argument, or a bit mask that doesn't match any of the valid values, or a bit mask that matches multiple valid values?

[sepavloff]

Updated patch

[arsenm]

Typo builting in commit message

clang/docs/LanguageExtensions.rst

3418 ↗

(On Diff #530041)

Maybe also mention it doesn't canonicalize its input

clang/test/CodeGen/isfpclass.c

55

Also tests without fenv access

57

Test some vectors?

clang/test/Sema/builtins.c

384 ↗

(On Diff #530041)

For any other float argument, 3 would accept implicit conversion. Do we just not do that for these type inferring intrinsics?

[sepavloff]

In D152351#4403904, @aaron.ballman wrote:

In D152351#4402785, @arsenm wrote:

Also should get mentioned in the builtin docs and release notes

+1, also, should there be named constants for the mask values?

I don't know where these constants could be placed.

clang/test/CodeGen/isfpclass.c

3

Half is added. But vectors cannot, because in this case result is also a vector.

[aaron.ballman]

In D152351#4409725, @sepavloff wrote:

In D152351#4403904, @aaron.ballman wrote:

In D152351#4402785, @arsenm wrote:

Also should get mentioned in the builtin docs and release notes

+1, also, should there be named constants for the mask values?

I don't know where these constants could be placed.

The preprocessor predefines a bunch of macros, so I was thinking along those same lines. e.g., https://github.com/llvm/llvm-project/blob/main/clang/lib/Frontend/InitPreprocessor.cpp#L737

[arsenm]

clang/test/CodeGen/isfpclass.c

3

Could copy what builtin_elementwise does. Should that be in this builtin, or should there be a separate builtin_elementwise_isfpclass?

[tschuett]

Could Clang offer a builtin.h file? It is always included. You place named constants and enums inside.

[sepavloff]

Updated patch

• Added named constants for data classes,
• Fixed documentation,
• Changed test for generated IR.

[sepavloff]

clang/test/CodeGen/isfpclass.c

3

Other math functions have separate elementwise functions. It looks natural to have separate elementwise function for this function as well.

clang/test/Sema/builtins.c

384 ↗

(On Diff #530041)

As any other classification function, this one is evaluated with semantic type. The test CodeGen/isfpclass.c demonstrates that type promotion is absent for _Float16.

[aaron.ballman]

Clang bits LGTM, thank you!

[sepavloff]

Thanks!

clang/include/clang/Basic/Builtins.def

 
 // Unary FP classification
 BUILTIN(__builtin_fpclassify, "iiiiii.", "FnctE")
 BUILTIN(__builtin_isfinite,   "i.", "FnctE")
 BUILTIN(__builtin_isinf,      "i.", "FnctE")
 BUILTIN(__builtin_isinf_sign, "i.", "FnctE")
 BUILTIN(__builtin_isnan,      "i.", "FnctE")
 BUILTIN(__builtin_isnormal,   "i.", "FnctE")
+BUILTIN(__builtin_isfpclass,  "iCi.", "nctE")
 
 // FP signbit builtins
 BUILTIN(__builtin_signbit, "i.", "Fnct")
 BUILTIN(__builtin_signbitf, "if", "Fnc")
 BUILTIN(__builtin_signbitl, "iLd", "Fnc")
 
 // Special FP builtins.
 BUILTIN(__builtin_canonicalize, "dd", "nc")

clang/lib/CodeGen/CGBuiltin.cpp

Value *Sub =
         Builder.CreateSub(llvm::ConstantInt::get(IntTy, ExpMask), AbsV);
     // V = sign bit (Sub) <=> V = (Sub < 0)
     V = Builder.CreateLShr(Sub, llvm::ConstantInt::get(IntTy, bitsize - 1));
     if (bitsize > 32)
       V = Builder.CreateTrunc(V, ConvertType(E->getType()));
     return RValue::get(V);
   }
 
+  case Builtin::BI__builtin_isfpclass: {
+    Expr::EvalResult Result;
+    if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
+      break;
+    uint64_t Test = Result.Val.getInt().getLimitedValue();
+    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
+    Value *V = EmitScalarExpr(E->getArg(1));
+    return RValue::get(Builder.CreateZExt(Builder.createIsFPClass(V, Test),
+                                          ConvertType(E->getType())));
+  }
+
   case Builtin::BI__builtin_nondeterministic_value: {
     llvm::Type *Ty = ConvertType(E->getArg(0)->getType());
 
     Value *Result = PoisonValue::get(Ty);
     Result = Builder.CreateFreeze(Result);
 
     return RValue::get(Result);
   }

clang/test/CodeGen/builtins.c

#define V(n,args) p(#n #args, (__builtin_##n args, 0))
   P(isless, (1., 2.));
   P(islessequal, (1., 2.));
   P(islessgreater, (1., 2.));
   P(isunordered, (1., 2.));
 
   P(isinf, (1.));
   P(isinf_sign, (1.));
   P(isnan, (1.));
+  P(isfpclass, (1, 1.));
 
   // Bitwise & Numeric Functions
 
   P(abs, (N));
 
   P(clz, (N));
   P(clzl, (N));
   P(clzll, (N));

clang/test/CodeGen/isfpclass.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -S -O1 -emit-llvm %s -o - | FileCheck %s
+
+_Bool check_isfpclass_finite(float x) {
+  return __builtin_isfpclass(504 /*Finite*/, x);
+}
+// CHECK-LABEL: define {{.*}} i1 @check_isfpclass_finite(
+// CHECK:         call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 504)
+
+_Bool check_isfpclass_finite_strict(float x) {
+#pragma STDC FENV_ACCESS ON
+  return __builtin_isfpclass(504 /*Finite*/, x);
+}
+// CHECK-LABEL: define {{.*}} i1 @check_isfpclass_finite_strict(
+// CHECK:         call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 504)
+
+_Bool check_isfpclass_nan_f32(float x) {
+#pragma STDC FENV_ACCESS ON
+  return __builtin_isfpclass(3 /*NaN*/, x);
+}
+// CHECK-LABEL: define {{.*}} i1 @check_isfpclass_nan_f32(
+// CHECK:         call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 3)
+
+_Bool check_isfpclass_nan_f64(double x) {
+#pragma STDC FENV_ACCESS ON
+  return __builtin_isfpclass(3 /*NaN*/, x);
+}
+// CHECK-LABEL: define {{.*}} i1 @check_isfpclass_nan_f64(
+// CHECK:         call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 3)

llvm/include/llvm/IR/IRBuilder.h

public:
 
   Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
                                         MDNode *DbgInfo);
 
   Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base,
                                          unsigned Index, unsigned FieldIndex,
                                          MDNode *DbgInfo);
 
+  Value *createIsFPClass(Value *FPNum, unsigned Test);
+
 private:
   /// Helper function that creates an assume intrinsic call that
   /// represents an alignment assumption on the provided pointer \p PtrValue
   /// with offset \p OffsetValue and alignment value \p AlignValue.
   CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
                                             Value *PtrValue, Value *AlignValue,
                                             Value *OffsetValue);
 

llvm/lib/IR/IRBuilder.cpp

Value *IRBuilderBase::CreatePreserveStructAccessIndex(
   Fn->addParamAttr(
       0, Attribute::get(Fn->getContext(), Attribute::ElementType, ElTy));
   if (DbgInfo)
     Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
 
   return Fn;
 }
 
+Value *IRBuilderBase::createIsFPClass(Value *FPNum, unsigned Test) {
+  auto TestV = llvm::ConstantInt::get(Type::getInt32Ty(Context), Test);
+  Module *M = BB->getParent()->getParent();
+  Function *FnIsFPClass =
+      Intrinsic::getDeclaration(M, Intrinsic::is_fpclass, {FPNum->getType()});
+  return CreateCall(FnIsFPClass, {FPNum, TestV});
+}
+
 CallInst *IRBuilderBase::CreateAlignmentAssumptionHelper(const DataLayout &DL,
                                                          Value *PtrValue,
                                                          Value *AlignValue,
                                                          Value *OffsetValue) {
   SmallVector<Value *, 4> Vals({PtrValue, AlignValue});
   if (OffsetValue)
     Vals.push_back(OffsetValue);
   OperandBundleDefT<Value *> AlignOpB("align", Vals);