Add missing roundtointegral builtin functions for some FP instructions to be generated from C-written codes

[joshua-arch1]

Summary

To generate FROUND instructions in https://reviews.llvm.org/D143982, we need to use llvm intrinsics in IR files. Now I add some corresponding builtin functions to make sure these roundtointegral instructions can be generated from C codes.

[efriedma]

LGTM. These are standard C23 functions, and glibc already has implementations; we should be recognizing them.

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_rintf16, "hh", "Fnc")
 BUILTIN(__builtin_rintl, "LdLd", "Fnc")
 BUILTIN(__builtin_rintf128, "LLdLLd", "Fnc")
 BUILTIN(__builtin_round, "dd"  , "Fnc")
 BUILTIN(__builtin_roundf, "ff"  , "Fnc")
 BUILTIN(__builtin_roundf16, "hh"  , "Fnc")
 BUILTIN(__builtin_roundl, "LdLd"  , "Fnc")
 BUILTIN(__builtin_roundf128, "LLdLLd"  , "Fnc")
+BUILTIN(__builtin_roundeven, "dd"  , "Fnc")
+BUILTIN(__builtin_roundevenf, "ff"  , "Fnc")
+BUILTIN(__builtin_roundevenf16, "hh"  , "Fnc")
+BUILTIN(__builtin_roundevenl, "LdLd"  , "Fnc")
+BUILTIN(__builtin_roundevenf128, "LLdLLd"  , "Fnc")
 BUILTIN(__builtin_scalbln , "ddLi", "Fne")
 BUILTIN(__builtin_scalblnf, "ffLi", "Fne")
 BUILTIN(__builtin_scalblnl, "LdLdLi", "Fne")
 BUILTIN(__builtin_scalblnf128, "LLdLLdLi", "Fne")
 BUILTIN(__builtin_scalbn , "ddi", "Fne")
 BUILTIN(__builtin_scalbnf, "ffi", "Fne")
 BUILTIN(__builtin_scalbnl, "LdLdi", "Fne")
 BUILTIN(__builtin_scalbnf128, "LLdLLdi", "Fne")

 LIBBUILTIN(rint, "dd", "fng", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(rintf, "ff", "fng", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(rintl, "LdLd", "fng", MATH_H, ALL_LANGUAGES)
 
 LIBBUILTIN(round, "dd", "fnc", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(roundf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(roundl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
 
+LIBBUILTIN(roundeven, "dd", "fnc", MATH_H, ALL_LANGUAGES)
+LIBBUILTIN(roundevenf, "ff", "fnc", MATH_H, ALL_LANGUAGES)
+LIBBUILTIN(roundevenl, "LdLd", "fnc", MATH_H, ALL_LANGUAGES)
+
 LIBBUILTIN(scalbln, "ddLi", "fne", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(scalblnf, "ffLi", "fne", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(scalblnl, "LdLdLi", "fne", MATH_H, ALL_LANGUAGES)
 
 LIBBUILTIN(scalbn, "ddi", "fne", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(scalbnf, "ffi", "fne", MATH_H, ALL_LANGUAGES)
 LIBBUILTIN(scalbnl, "LdLdi", "fne", MATH_H, ALL_LANGUAGES)
 

clang/lib/CodeGen/CGBuiltin.cpp

if (FD->hasAttr<ConstAttr>() ||
     case Builtin::BI__builtin_roundf:
     case Builtin::BI__builtin_roundf16:
     case Builtin::BI__builtin_roundl:
     case Builtin::BI__builtin_roundf128:
       return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
                                    Intrinsic::round,
                                    Intrinsic::experimental_constrained_round));
 
+    case Builtin::BIroundeven:
+    case Builtin::BIroundevenf:
+    case Builtin::BIroundevenl:
+    case Builtin::BI__builtin_roundeven:
+    case Builtin::BI__builtin_roundevenf:
+    case Builtin::BI__builtin_roundevenf16:
+    case Builtin::BI__builtin_roundevenl:
+    case Builtin::BI__builtin_roundevenf128:
+      return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
+                                   Intrinsic::roundeven,
+                                   Intrinsic::experimental_constrained_roundeven));
+                                   
     case Builtin::BIsin:
     case Builtin::BIsinf:
     case Builtin::BIsinl:
     case Builtin::BI__builtin_sin:
     case Builtin::BI__builtin_sinf:
     case Builtin::BI__builtin_sinf16:
     case Builtin::BI__builtin_sinl:
     case Builtin::BI__builtin_sinf128:

clang/test/CodeGen/builtins.c

void test_float_builtin_ops(float F, double D, long double LD) {
   // CHECK: call float @llvm.round.f32
 
   resd = __builtin_round(D);
   // CHECK: call double @llvm.round.f64
 
   resld = __builtin_roundl(LD);
   // CHECK: call x86_fp80 @llvm.round.f80
 
+  resf = __builtin_roundevenf(F);
+  // CHECK: call float @llvm.roundeven.f32
+
+  resd = __builtin_roundeven(D);
+  // CHECK: call double @llvm.roundeven.f64
+
+  resld = __builtin_roundevenl(LD);
+  // CHECK: call x86_fp80 @llvm.roundeven.f80
+  
   resli = __builtin_lroundf (F);
   // CHECK: call i64 @llvm.lround.i64.f32
 
   resli = __builtin_lround (D);
   // CHECK: call i64 @llvm.lround.i64.f64
 
   resli = __builtin_lroundl (LD);
   // CHECK: call i64 @llvm.lround.i64.f80