[FPEnv] Intrinsic llvm.roundeven

[sepavloff]

Summary

This intrinsic implements IEEE-754 operation roundToIntegralTiesToEven,
and performs rounding to the nearest integer value, rounding halfway
cases to even. This intrinsic represents the missed case of IEEE-754
rounding operations and now llvm provides full support of the rounding
operations defined by the standard.

[arsenm]

llvm/docs/LangRef.rst

13163–13166

Isn't this the same as rint? Since the default rounding mode is assumed

13197

I've never heard of this C standard function?

[efriedma]

llvm/docs/LangRef.rst

13163–13166

The name is a hint that we should prefer to lower to a library function named "roundeven", if we can't generate an inline sequence. Other than that, yes, it's identical.

I vaguely recall that I tried to merge llvm.rint and llvm.nearbyint at some point, but someone ran into issues with missing symbols. I can try to dig it up if you think it's important.

13197

It's part of TS 18661-1, which I think is proposed to be part of the next version of the C standard.

[arsenm]

llvm/docs/LangRef.rst

13163–13166

I don't think the intrinsic name should ever influence codegen that way. We should not have redundant intrinsics, especially for some weird lowering hint

[efriedma]

llvm/docs/LangRef.rst

13163–13166

See https://reviews.llvm.org/rL299247 for recent history of this.

[sepavloff]

llvm/docs/LangRef.rst

13163–13166

Isn't this the same as rint? Since the default rounding mode is assumed

roundeven does not assume any mode. It always rounds to nearest, ties to even.
If we eventually accept the viewpoint that default mode may be assumed always in the absence of pragma FENV_ACCESS, then it is more natural to replace rint with this intrinsic.

The name is a hint that we should prefer to lower to a library function named "roundeven", if we can't generate an inline sequence. Other than that, yes, it's identical.

There is a library function roundeven, which of course differs from any other rounding function.

I don't think the intrinsic name should ever influence codegen that way. We should not have redundant intrinsics, especially for some weird lowering hint

This is a function defined in the recent C standard draft http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2454.pdf, 7.12.9.8.

See https://reviews.llvm.org/rL299247 for recent history of this.

It is semantically necessary change as rint and nearbyint are different functions if we are interested with FP exception status.

[sepavloff]

Ping.

[arsenm]

llvm/docs/LangRef.rst

13163–13166

If we eventually accept the viewpoint that default mode may be assumed always in the absence of pragma FENV_ACCESS, then it is more natural to replace rint with this intrinsic.

This is already very much the case. The regular FP operations and non constrained intrinsics assume the default FP environment

[sepavloff]

llvm/docs/LangRef.rst

13163–13166

If we eventually accept the viewpoint that default mode may be assumed always in the absence of pragma FENV_ACCESS, then it is more natural to replace rint with this intrinsic.

This is already very much the case. The regular FP operations and non constrained intrinsics assume the default FP environment

That's true. We need this intrinsic to implement nearbyint and rint in default mode.

[sepavloff]

Although the patch appears large, most of it is made by copy-paste of llvm.round pieces.

[sepavloff]

Any feedback?

[andrew.w.kaylor]

llvm/docs/LangRef.rst

13163–13166

It is semantically necessary change as rint and nearbyint are different functions if we are interested with FP exception status.

In terms of LLVM IR, the unconstrained intrinsics llvm.rint, llvm.nearbyint, and llvm.roundeven are semantially identical. Backends should be able to lower them all the same way. If not, that's a bug. For this reason, I'm not sure we need all three.

[sepavloff]

llvm/docs/LangRef.rst

13163–13166

In terms of LLVM IR, the unconstrained intrinsics llvm.rint, llvm.nearbyint, and llvm.roundeven are semantially identical. Backends should be able to lower them all the same way. If not, that's a bug. For this reason, I'm not sure we need all three.

Yes, unconstrained llvm.rint and llvm.nearbyint implement roundToIntegralTiesToEven in default mode, so they are not needed. I asked some time ago, if we need these intrinsics (http://lists.llvm.org/pipermail/cfe-dev/2020-March/064803.html). It looks like there is no reason to keep them, so they can be removed, only constrained versions should remain. Of unconstrained intrinsic only llvm.roundeven should survive as it is proposed exactly for this kind of rounding.

[sepavloff]

Rebased patch

[sepavloff]

Replacement of llvm.nearbyint and llvm.rint with llvm.roundeven in the case of default FP environment is an optimization. If it is not done, these intrinsics will be converted into runtime library calls and the semantics expected by user will not be broken. While pragma STDC FENV_ACCESS is not fully supported, compiler should not do such optimization, because it would made functions nearbyint* and rint* unavailable.

This patch only introduces new intrinsic function that will be used to implement functions roundeven* defined in new C standard.

[efriedma]

I think the experimental_constrained_roundeven part is uncontroversial.

For the rest, there are two competing interests here:

1. We don't want multiple intrinsics that represent the same thing.
2. Transforming calls to roundeven/rint/nearbyint to one of the other functions is surprising, even if it's legal in some sense, and will likely break some practical use because we don't control the C library.

Violating (1) seems annoying, but not much of a practical problem; the few bits of code that actually care can easily check for three names instead of one. Violating (2) seems like fodder for weird bug reports I don't want to deal with. Given that, I think we should accept this patch as-is.

[sepavloff]

Any feedback?

[sepavloff]

Rebased patch

[craig.topper]

llvm/lib/Analysis/ConstantFolding.cpp

1416

This should probably be with ceil/floor/trunc etc. further down?

1506

should constrained_roundeven be here?

llvm/test/Transforms/InstCombine/double-float-shrink-2.ll

84

This comment should be roundevenf

[sepavloff]

Updated patch

[sepavloff]

llvm/lib/Analysis/ConstantFolding.cpp

1416

Sure.

1506

Indeed. Thank you!

[sepavloff]

Rebased patch

[craig.topper]

LGTM

llvm/docs/LangRef.rst

 type.
 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``round``
 functions would, and handles error conditions in the same way.
 
+'``llvm.roundeven.*``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+This is an overloaded intrinsic. You can use ``llvm.roundeven`` on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.
+
+::
+
+      declare float     @llvm.roundeven.f32(float  %Val)
+      declare double    @llvm.roundeven.f64(double %Val)
+      declare x86_fp80  @llvm.roundeven.f80(x86_fp80  %Val)
+      declare fp128     @llvm.roundeven.f128(fp128 %Val)
+      declare ppc_fp128 @llvm.roundeven.ppcf128(ppc_fp128  %Val)
+
+Overview:
+"""""""""
+
+The '``llvm.roundeven.*``' intrinsics returns the operand rounded to the nearest
+integer in floating-point format rounding halfway cases to even (that is, to the
+nearest value that is an even integer).
+
+Arguments:
+""""""""""
+
+The argument and return value are floating-point numbers of the same type.
+
+Semantics:
+""""""""""
+
+This function implements IEEE-754 operation ``roundToIntegralTiesToEven``. It
+also behaves in the same way as C standard function ``roundeven``, except that
+it does not raise floating point exceptions.
+
+
 '``llvm.lround.*``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.lround`` on any
 floating-point type. Not all targets support all types however.

 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``round`` functions
 would and handles error conditions in the same way.
 
 
+'``llvm.experimental.constrained.roundeven``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+::
+
+      declare <type>
+      @llvm.experimental.constrained.roundeven(<type> <op1>,
+                                               metadata <exception behavior>)
+
+Overview:
+"""""""""
+
+The '``llvm.experimental.constrained.roundeven``' intrinsic returns the first
+operand rounded to the nearest integer in floating-point format, rounding
+halfway cases to even (that is, to the nearest value that is an even integer),
+regardless of the current rounding direction.
+
+Arguments:
+""""""""""
+
+The first argument and the return value are floating-point numbers of the same
+type.
+
+The second argument specifies the exception behavior as described above.
+
+Semantics:
+""""""""""
+
+This function implements IEEE-754 operation ``roundToIntegralTiesToEven``. It
+also behaves in the same way as C standard function ``roundeven`` and can signal
+the invalid operation exception for a SNAN operand.
+
+
 '``llvm.experimental.constrained.lround``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 

llvm/include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_ENUM_INTERNAL(rintl)
 TLI_DEFINE_STRING_INTERNAL("rintl")
 /// int rmdir(const char *path);
 TLI_DEFINE_ENUM_INTERNAL(rmdir)
 TLI_DEFINE_STRING_INTERNAL("rmdir")
 /// double round(double x);
 TLI_DEFINE_ENUM_INTERNAL(round)
 TLI_DEFINE_STRING_INTERNAL("round")
+/// double roundeven(double x);
+TLI_DEFINE_ENUM_INTERNAL(roundeven)
+TLI_DEFINE_STRING_INTERNAL("roundeven")
+/// float roundevenf(float x);
+TLI_DEFINE_ENUM_INTERNAL(roundevenf)
+TLI_DEFINE_STRING_INTERNAL("roundevenf")
+/// long double roundevenl(long double x);
+TLI_DEFINE_ENUM_INTERNAL(roundevenl)
+TLI_DEFINE_STRING_INTERNAL("roundevenl")
 /// float roundf(float x);
 TLI_DEFINE_ENUM_INTERNAL(roundf)
 TLI_DEFINE_STRING_INTERNAL("roundf")
 /// long double roundl(long double x);
 TLI_DEFINE_ENUM_INTERNAL(roundl)
 TLI_DEFINE_STRING_INTERNAL("roundl")
 /// int scanf(const char *restrict format, ... );
 TLI_DEFINE_ENUM_INTERNAL(scanf)

llvm/include/llvm/CodeGen/BasicTTIImpl.h

case Intrinsic::nearbyint:
       ISDs.push_back(ISD::FNEARBYINT);
       break;
     case Intrinsic::rint:
       ISDs.push_back(ISD::FRINT);
       break;
     case Intrinsic::round:
       ISDs.push_back(ISD::FROUND);
       break;
+    case Intrinsic::roundeven:
+      ISDs.push_back(ISD::FROUNDEVEN);
+      break;
     case Intrinsic::pow:
       ISDs.push_back(ISD::FPOW);
       break;
     case Intrinsic::fma:
       ISDs.push_back(ISD::FMA);
       break;
     case Intrinsic::fmuladd:
       ISDs.push_back(ISD::FMA);

llvm/include/llvm/CodeGen/ISDOpcodes.h

enum NodeType {
   STRICT_FLOG2,
   STRICT_FRINT,
   STRICT_FNEARBYINT,
   STRICT_FMAXNUM,
   STRICT_FMINNUM,
   STRICT_FCEIL,
   STRICT_FFLOOR,
   STRICT_FROUND,
+  STRICT_FROUNDEVEN,
   STRICT_FTRUNC,
   STRICT_LROUND,
   STRICT_LLROUND,
   STRICT_LRINT,
   STRICT_LLRINT,
   STRICT_FMAXIMUM,
   STRICT_FMINIMUM,
 
enum NodeType {
   FLOG10,
   FEXP,
   FEXP2,
   FCEIL,
   FTRUNC,
   FRINT,
   FNEARBYINT,
   FROUND,
+  FROUNDEVEN,
   FFLOOR,
   LROUND,
   LLROUND,
   LRINT,
   LLRINT,
 
   /// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
   /// values.

llvm/include/llvm/IR/ConstrainedOps.def

 DAG_FUNCTION(minnum,          2, 0, experimental_constrained_minnum,     FMINNUM)
 DAG_FUNCTION(maximum,         2, 0, experimental_constrained_maximum,    FMAXIMUM)
 DAG_FUNCTION(minimum,         2, 0, experimental_constrained_minimum,    FMINIMUM)
 DAG_FUNCTION(nearbyint,       1, 1, experimental_constrained_nearbyint,  FNEARBYINT)
 DAG_FUNCTION(pow,             2, 1, experimental_constrained_pow,        FPOW)
 DAG_FUNCTION(powi,            2, 1, experimental_constrained_powi,       FPOWI)
 DAG_FUNCTION(rint,            1, 1, experimental_constrained_rint,       FRINT)
 DAG_FUNCTION(round,           1, 0, experimental_constrained_round,      FROUND)
+DAG_FUNCTION(roundeven,       1, 0, experimental_constrained_roundeven,  FROUNDEVEN)
 DAG_FUNCTION(sin,             1, 1, experimental_constrained_sin,        FSIN)
 DAG_FUNCTION(sqrt,            1, 1, experimental_constrained_sqrt,       FSQRT)
 DAG_FUNCTION(trunc,           1, 0, experimental_constrained_trunc,      FTRUNC)
 
 // This is definition for fmuladd intrinsic function, that is converted into
 // constrained FMA or FMUL + FADD intrinsics.
 FUNCTION(fmuladd,         3, 1, experimental_constrained_fmuladd)
 
 #undef INSTRUCTION
 #undef FUNCTION
 #undef CMP_INSTRUCTION
 #undef DAG_INSTRUCTION
 #undef DAG_FUNCTION

llvm/include/llvm/IR/Intrinsics.td

let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_copysign : Intrinsic<[llvm_anyfloat_ty],
                                [LLVMMatchType<0>, LLVMMatchType<0>]>;
   def int_floor : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_ceil  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_trunc : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_rint  : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_nearbyint : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_round : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
+  def int_roundeven    : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>;
   def int_canonicalize : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
                                    [IntrNoMem]>;
 
   def int_lround : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_llround : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_lrint : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
   def int_llrint : Intrinsic<[llvm_anyint_ty], [llvm_anyfloat_ty]>;
 }
def int_experimental_constrained_lround : Intrinsic<[ llvm_anyint_ty ],
                                                       [ llvm_anyfloat_ty,
                                                         llvm_metadata_ty ]>;
   def int_experimental_constrained_llround : Intrinsic<[ llvm_anyint_ty ],
                                                        [ llvm_anyfloat_ty,
                                                          llvm_metadata_ty ]>;
   def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                       llvm_metadata_ty ]>;
+  def int_experimental_constrained_roundeven : Intrinsic<[ llvm_anyfloat_ty ],
+                                                         [ LLVMMatchType<0>,
+                                                           llvm_metadata_ty ]>;
   def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                        llvm_metadata_ty ]>;
 
   // Constrained floating-point comparison (quiet and signaling variants).
   // Third operand is the predicate represented as a metadata string.
   def int_experimental_constrained_fcmp
       : Intrinsic<[ LLVMScalarOrSameVectorWidth<0, llvm_i1_ty> ],

llvm/include/llvm/IR/RuntimeLibcalls.def

 HANDLE_LIBCALL(NEARBYINT_F80, "nearbyintl")
 HANDLE_LIBCALL(NEARBYINT_F128, "nearbyintl")
 HANDLE_LIBCALL(NEARBYINT_PPCF128, "nearbyintl")
 HANDLE_LIBCALL(ROUND_F32, "roundf")
 HANDLE_LIBCALL(ROUND_F64, "round")
 HANDLE_LIBCALL(ROUND_F80, "roundl")
 HANDLE_LIBCALL(ROUND_F128, "roundl")
 HANDLE_LIBCALL(ROUND_PPCF128, "roundl")
+HANDLE_LIBCALL(ROUNDEVEN_F32, "roundevenf")
+HANDLE_LIBCALL(ROUNDEVEN_F64, "roundeven")
+HANDLE_LIBCALL(ROUNDEVEN_F80, "roundevenl")
+HANDLE_LIBCALL(ROUNDEVEN_F128, "roundevenl")
+HANDLE_LIBCALL(ROUNDEVEN_PPCF128, "roundevenl")
 HANDLE_LIBCALL(FLOOR_F32, "floorf")
 HANDLE_LIBCALL(FLOOR_F64, "floor")
 HANDLE_LIBCALL(FLOOR_F80, "floorl")
 HANDLE_LIBCALL(FLOOR_F128, "floorl")
 HANDLE_LIBCALL(FLOOR_PPCF128, "floorl")
 HANDLE_LIBCALL(COPYSIGN_F32, "copysignf")
 HANDLE_LIBCALL(COPYSIGN_F64, "copysign")
 HANDLE_LIBCALL(COPYSIGN_F80, "copysignl")

llvm/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   case Intrinsic::bswap:
   case Intrinsic::ctpop:
   case Intrinsic::ctlz:
   case Intrinsic::cttz:
   case Intrinsic::fshl:
   case Intrinsic::fshr:
   case Intrinsic::launder_invariant_group:
   case Intrinsic::strip_invariant_group:
   case Intrinsic::masked_load:
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::ssub_with_overflow:
   case Intrinsic::usub_with_overflow:
   case Intrinsic::smul_with_overflow:
   case Intrinsic::umul_with_overflow:
   case Intrinsic::sadd_sat:
   case Intrinsic::uadd_sat:
bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   // exceptions even for SNANs.
   case Intrinsic::fabs:
   case Intrinsic::copysign:
   // Non-constrained variants of rounding operations means default FP
   // environment, they can be folded in any case.
   case Intrinsic::ceil:
   case Intrinsic::floor:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::trunc:
   case Intrinsic::nearbyint:
   case Intrinsic::rint:
   // Constrained intrinsics can be folded if FP environment is known
   // to compiler.
   case Intrinsic::experimental_constrained_ceil:
   case Intrinsic::experimental_constrained_floor:
   case Intrinsic::experimental_constrained_round:
+  case Intrinsic::experimental_constrained_roundeven:
   case Intrinsic::experimental_constrained_trunc:
   case Intrinsic::experimental_constrained_nearbyint:
   case Intrinsic::experimental_constrained_rint:
     return true;
   default:
     return false;
   case Intrinsic::not_intrinsic: break;
   }
 
if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint) {
       return ConstantFP::get(Ty->getContext(), U);
     }
 
     if (IntrinsicID == Intrinsic::round) {
       U.roundToIntegral(APFloat::rmNearestTiesToAway);
       return ConstantFP::get(Ty->getContext(), U);
     }
 
+    if (IntrinsicID == Intrinsic::roundeven) {
+      U.roundToIntegral(APFloat::rmNearestTiesToEven);
+      return ConstantFP::get(Ty->getContext(), U);
+    }
+
     if (IntrinsicID == Intrinsic::ceil) {
       U.roundToIntegral(APFloat::rmTowardPositive);
       return ConstantFP::get(Ty->getContext(), U);
     }
 
     if (IntrinsicID == Intrinsic::floor) {
       U.roundToIntegral(APFloat::rmTowardNegative);
       return ConstantFP::get(Ty->getContext(), U);

llvm/lib/Analysis/InstructionSimplify.cpp

static bool IsIdempotent(Intrinsic::ID ID) {
   // Unary idempotent: f(f(x)) = f(x)
   case Intrinsic::fabs:
   case Intrinsic::floor:
   case Intrinsic::ceil:
   case Intrinsic::trunc:
   case Intrinsic::rint:
   case Intrinsic::nearbyint:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::canonicalize:
     return true;
   }
 }
 
 static Value *SimplifyRelativeLoad(Constant *Ptr, Constant *Offset,
                                    const DataLayout &DL) {
   GlobalValue *PtrSym;
case Intrinsic::log10:
     if (Q.CxtI->hasAllowReassoc() &&
         match(Op0, m_Intrinsic<Intrinsic::pow>(m_SpecificFP(10.0),
                                                m_Value(X)))) return X;
     break;
   case Intrinsic::floor:
   case Intrinsic::trunc:
   case Intrinsic::ceil:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::nearbyint:
   case Intrinsic::rint: {
     // floor (sitofp x) -> sitofp x
     // floor (uitofp x) -> uitofp x
     //
     // Converting from int always results in a finite integral number or
     // infinity. For either of those inputs, these rounding functions always
     // return the same value, so the rounding can be eliminated.

llvm/lib/Analysis/TargetLibraryInfo.cpp

bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_nearbyintf:
   case LibFunc_nearbyintl:
   case LibFunc_rint:
   case LibFunc_rintf:
   case LibFunc_rintl:
   case LibFunc_round:
   case LibFunc_roundf:
   case LibFunc_roundl:
+  case LibFunc_roundeven:
+  case LibFunc_roundevenf:
+  case LibFunc_roundevenl:
   case LibFunc_sin:
   case LibFunc_sinf:
   case LibFunc_sinh:
   case LibFunc_sinh_finite:
   case LibFunc_sinhf:
   case LibFunc_sinhf_finite:
   case LibFunc_sinhl:
   case LibFunc_sinhl_finite:

llvm/lib/Analysis/ValueTracking.cpp

Intrinsic::ID llvm::getIntrinsicForCallSite(const CallBase &CB,
   case LibFunc_nearbyint:
   case LibFunc_nearbyintf:
   case LibFunc_nearbyintl:
     return Intrinsic::nearbyint;
   case LibFunc_round:
   case LibFunc_roundf:
   case LibFunc_roundl:
     return Intrinsic::round;
+  case LibFunc_roundeven:
+  case LibFunc_roundevenf:
+  case LibFunc_roundevenl:
+    return Intrinsic::roundeven;
   case LibFunc_pow:
   case LibFunc_powf:
   case LibFunc_powl:
     return Intrinsic::pow;
   case LibFunc_sqrt:
   case LibFunc_sqrtf:
   case LibFunc_sqrtl:
     return Intrinsic::sqrt;
if (const auto *II = dyn_cast<IntrinsicInst>(V)) {
     case Intrinsic::exp:
     case Intrinsic::exp2:
     case Intrinsic::floor:
     case Intrinsic::ceil:
     case Intrinsic::trunc:
     case Intrinsic::rint:
     case Intrinsic::nearbyint:
     case Intrinsic::round:
+    case Intrinsic::roundeven:
       return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1);
     case Intrinsic::sqrt:
       return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1) &&
              CannotBeOrderedLessThanZero(II->getArgOperand(0), TLI);
     case Intrinsic::minnum:
     case Intrinsic::maxnum:
       // If either operand is not NaN, the result is not NaN.
       return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1) ||

llvm/lib/Analysis/VectorUtils.cpp

bool llvm::isTriviallyVectorizable(Intrinsic::ID ID) {
   case Intrinsic::maximum:
   case Intrinsic::copysign:
   case Intrinsic::floor:
   case Intrinsic::ceil:
   case Intrinsic::trunc:
   case Intrinsic::rint:
   case Intrinsic::nearbyint:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::pow:
   case Intrinsic::fma:
   case Intrinsic::fmuladd:
   case Intrinsic::powi:
   case Intrinsic::canonicalize:
     return true;
   default:
     return false;

llvm/lib/CodeGen/IntrinsicLowering.cpp

void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
   case Intrinsic::trunc: {
     ReplaceFPIntrinsicWithCall(CI, "truncf", "trunc", "truncl");
     break;
   }
   case Intrinsic::round: {
     ReplaceFPIntrinsicWithCall(CI, "roundf", "round", "roundl");
     break;
   }
+  case Intrinsic::roundeven: {
+    ReplaceFPIntrinsicWithCall(CI, "roundevenf", "roundeven", "roundevenl");
+    break;
+  }
   case Intrinsic::copysign: {
     ReplaceFPIntrinsicWithCall(CI, "copysignf", "copysign", "copysignl");
     break;
   }
   case Intrinsic::flt_rounds:
      // Lower to "round to the nearest"
      if (!CI->getType()->isVoidTy())
        CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
   case ISD::FROUND:
   case ISD::STRICT_FROUND:
     ExpandFPLibCall(Node, RTLIB::ROUND_F32,
                     RTLIB::ROUND_F64,
                     RTLIB::ROUND_F80,
                     RTLIB::ROUND_F128,
                     RTLIB::ROUND_PPCF128, Results);
     break;
+  case ISD::FROUNDEVEN:
+  case ISD::STRICT_FROUNDEVEN:
+    ExpandFPLibCall(Node, RTLIB::ROUNDEVEN_F32,
+                    RTLIB::ROUNDEVEN_F64,
+                    RTLIB::ROUNDEVEN_F80,
+                    RTLIB::ROUNDEVEN_F128,
+                    RTLIB::ROUNDEVEN_PPCF128, Results);
+    break;
   case ISD::FPOWI:
   case ISD::STRICT_FPOWI: {
     RTLIB::Libcall LC;
     switch (Node->getSimpleValueType(0).SimpleTy) {
     default: llvm_unreachable("Unexpected request for libcall!");
     case MVT::f32: LC = RTLIB::POWI_F32; break;
     case MVT::f64: LC = RTLIB::POWI_F64; break;
     case MVT::f80: LC = RTLIB::POWI_F80; break;
Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
                                   Tmp3, DAG.getIntPtrConstant(isTrunc, dl)));
     break;
   }
   case ISD::FFLOOR:
   case ISD::FCEIL:
   case ISD::FRINT:
   case ISD::FNEARBYINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FTRUNC:
   case ISD::FNEG:
   case ISD::FSQRT:
   case ISD::FSIN:
   case ISD::FCOS:
   case ISD::FLOG:
   case ISD::FLOG2:
   case ISD::FLOG10:

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

#endif
     case ISD::STRICT_FPOWI:
     case ISD::FPOWI:       R = SoftenFloatRes_FPOWI(N); break;
     case ISD::STRICT_FREM:
     case ISD::FREM:        R = SoftenFloatRes_FREM(N); break;
     case ISD::STRICT_FRINT:
     case ISD::FRINT:       R = SoftenFloatRes_FRINT(N); break;
     case ISD::STRICT_FROUND:
     case ISD::FROUND:      R = SoftenFloatRes_FROUND(N); break;
+    case ISD::STRICT_FROUNDEVEN:
+    case ISD::FROUNDEVEN:  R = SoftenFloatRes_FROUNDEVEN(N); break;
     case ISD::STRICT_FSIN:
     case ISD::FSIN:        R = SoftenFloatRes_FSIN(N); break;
     case ISD::STRICT_FSQRT:
     case ISD::FSQRT:       R = SoftenFloatRes_FSQRT(N); break;
     case ISD::STRICT_FSUB:
     case ISD::FSUB:        R = SoftenFloatRes_FSUB(N); break;
     case ISD::STRICT_FTRUNC:
     case ISD::FTRUNC:      R = SoftenFloatRes_FTRUNC(N); break;
SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
   return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
                                               RTLIB::ROUND_F32,
                                               RTLIB::ROUND_F64,
                                               RTLIB::ROUND_F80,
                                               RTLIB::ROUND_F128,
                                               RTLIB::ROUND_PPCF128));
 }
 
+SDValue DAGTypeLegalizer::SoftenFloatRes_FROUNDEVEN(SDNode *N) {
+  return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
+                                              RTLIB::ROUNDEVEN_F32,
+                                              RTLIB::ROUNDEVEN_F64,
+                                              RTLIB::ROUNDEVEN_F80,
+                                              RTLIB::ROUNDEVEN_F128,
+                                              RTLIB::ROUNDEVEN_PPCF128));
+}
+
 SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
   return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
                                               RTLIB::SIN_F32,
                                               RTLIB::SIN_F64,
                                               RTLIB::SIN_F80,
                                               RTLIB::SIN_F128,
                                               RTLIB::SIN_PPCF128));
 }
#endif
   case ISD::FPOW:       ExpandFloatRes_FPOW(N, Lo, Hi); break;
   case ISD::STRICT_FPOWI:
   case ISD::FPOWI:      ExpandFloatRes_FPOWI(N, Lo, Hi); break;
   case ISD::FREEZE:     ExpandFloatRes_FREEZE(N, Lo, Hi); break;
   case ISD::STRICT_FRINT:
   case ISD::FRINT:      ExpandFloatRes_FRINT(N, Lo, Hi); break;
   case ISD::STRICT_FROUND:
   case ISD::FROUND:     ExpandFloatRes_FROUND(N, Lo, Hi); break;
+  case ISD::STRICT_FROUNDEVEN:
+  case ISD::FROUNDEVEN: ExpandFloatRes_FROUNDEVEN(N, Lo, Hi); break;
   case ISD::STRICT_FSIN:
   case ISD::FSIN:       ExpandFloatRes_FSIN(N, Lo, Hi); break;
   case ISD::STRICT_FSQRT:
   case ISD::FSQRT:      ExpandFloatRes_FSQRT(N, Lo, Hi); break;
   case ISD::STRICT_FSUB:
   case ISD::FSUB:       ExpandFloatRes_FSUB(N, Lo, Hi); break;
   case ISD::STRICT_FTRUNC:
   case ISD::FTRUNC:     ExpandFloatRes_FTRUNC(N, Lo, Hi); break;
void DAGTypeLegalizer::ExpandFloatRes_FROUND(SDNode *N,
   ExpandFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
                                        RTLIB::ROUND_F32,
                                        RTLIB::ROUND_F64,
                                        RTLIB::ROUND_F80,
                                        RTLIB::ROUND_F128,
                                        RTLIB::ROUND_PPCF128), Lo, Hi);
 }
 
+void DAGTypeLegalizer::ExpandFloatRes_FROUNDEVEN(SDNode *N,
+                                             SDValue &Lo, SDValue &Hi) {
+  ExpandFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
+                                       RTLIB::ROUNDEVEN_F32,
+                                       RTLIB::ROUNDEVEN_F64,
+                                       RTLIB::ROUNDEVEN_F80,
+                                       RTLIB::ROUNDEVEN_F128,
+                                       RTLIB::ROUNDEVEN_PPCF128), Lo, Hi);
+}
+
 void DAGTypeLegalizer::ExpandFloatRes_FSIN(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) {
   ExpandFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
                                        RTLIB::SIN_F32, RTLIB::SIN_F64,
                                        RTLIB::SIN_F80, RTLIB::SIN_F128,
                                        RTLIB::SIN_PPCF128), Lo, Hi);
 }
 
#endif
     case ISD::FFLOOR:
     case ISD::FLOG:
     case ISD::FLOG2:
     case ISD::FLOG10:
     case ISD::FNEARBYINT:
     case ISD::FNEG:
     case ISD::FRINT:
     case ISD::FROUND:
+    case ISD::FROUNDEVEN:
     case ISD::FSIN:
     case ISD::FSQRT:
     case ISD::FTRUNC:
     case ISD::FCANONICALIZE: R = PromoteFloatRes_UnaryOp(N); break;
 
     // Binary FP Operations
     case ISD::FADD:
     case ISD::FDIV:
#endif
   case ISD::FLOG:
   case ISD::FLOG2:
   case ISD::FLOG10:
   case ISD::FNEARBYINT:
   case ISD::FNEG:
   case ISD::FREEZE:
   case ISD::FRINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FSIN:
   case ISD::FSQRT:
   case ISD::FTRUNC:
   case ISD::FCANONICALIZE: R = SoftPromoteHalfRes_UnaryOp(N); break;
 
   // Binary FP Operations
   case ISD::FADD:
   case ISD::FDIV:

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.h

private:
   SDValue SoftenFloatRes_FP16_TO_FP(SDNode *N);
   SDValue SoftenFloatRes_FP_ROUND(SDNode *N);
   SDValue SoftenFloatRes_FPOW(SDNode *N);
   SDValue SoftenFloatRes_FPOWI(SDNode *N);
   SDValue SoftenFloatRes_FREEZE(SDNode *N);
   SDValue SoftenFloatRes_FREM(SDNode *N);
   SDValue SoftenFloatRes_FRINT(SDNode *N);
   SDValue SoftenFloatRes_FROUND(SDNode *N);
+  SDValue SoftenFloatRes_FROUNDEVEN(SDNode *N);
   SDValue SoftenFloatRes_FSIN(SDNode *N);
   SDValue SoftenFloatRes_FSQRT(SDNode *N);
   SDValue SoftenFloatRes_FSUB(SDNode *N);
   SDValue SoftenFloatRes_FTRUNC(SDNode *N);
   SDValue SoftenFloatRes_LOAD(SDNode *N);
   SDValue SoftenFloatRes_SELECT(SDNode *N);
   SDValue SoftenFloatRes_SELECT_CC(SDNode *N);
   SDValue SoftenFloatRes_UNDEF(SDNode *N);
private:
   void ExpandFloatRes_FNEG      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FP_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FPOW      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FPOWI     (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FREEZE    (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FREM      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FRINT     (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FROUND    (SDNode *N, SDValue &Lo, SDValue &Hi);
+  void ExpandFloatRes_FROUNDEVEN(SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FSIN      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FSQRT     (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FSUB      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_FTRUNC    (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_LOAD      (SDNode *N, SDValue &Lo, SDValue &Hi);
   void ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo, SDValue &Hi);
 
   // Float Operand Expansion.

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

#include "llvm/IR/ConstrainedOps.def"
   case ISD::FLOG10:
   case ISD::FEXP:
   case ISD::FEXP2:
   case ISD::FCEIL:
   case ISD::FTRUNC:
   case ISD::FRINT:
   case ISD::FNEARBYINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FFLOOR:
   case ISD::FP_ROUND:
   case ISD::FP_EXTEND:
   case ISD::FMA:
   case ISD::SIGN_EXTEND_INREG:
   case ISD::ANY_EXTEND_VECTOR_INREG:
   case ISD::SIGN_EXTEND_VECTOR_INREG:
   case ISD::ZERO_EXTEND_VECTOR_INREG:

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

#endif
   case ISD::FNEARBYINT:
   case ISD::FNEG:
   case ISD::FREEZE:
   case ISD::FP_EXTEND:
   case ISD::FP_TO_SINT:
   case ISD::FP_TO_UINT:
   case ISD::FRINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FSIN:
   case ISD::FSQRT:
   case ISD::FTRUNC:
   case ISD::SIGN_EXTEND:
   case ISD::SINT_TO_FP:
   case ISD::TRUNCATE:
   case ISD::UINT_TO_FP:
   case ISD::ZERO_EXTEND:
#endif
   case ISD::FNEG:
   case ISD::FREEZE:
   case ISD::FP_EXTEND:
   case ISD::FP_ROUND:
   case ISD::FP_TO_SINT:
   case ISD::FP_TO_UINT:
   case ISD::FRINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FSIN:
   case ISD::FSQRT:
   case ISD::FTRUNC:
   case ISD::SINT_TO_FP:
   case ISD::TRUNCATE:
   case ISD::UINT_TO_FP:
   case ISD::FCANONICALIZE:
     SplitVecRes_UnaryOp(N, Lo, Hi);
#include "llvm/IR/ConstrainedOps.def"
   case ISD::FEXP2:
   case ISD::FFLOOR:
   case ISD::FLOG:
   case ISD::FLOG10:
   case ISD::FLOG2:
   case ISD::FNEARBYINT:
   case ISD::FRINT:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FSIN:
   case ISD::FSQRT:
   case ISD::FTRUNC: {
     // We're going to widen this vector op to a legal type by padding with undef
     // elements. If the wide vector op is eventually going to be expanded to
     // scalar libcalls, then unroll into scalar ops now to avoid unnecessary
     // libcalls on the undef elements.
     EVT VT = N->getValueType(0);

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

bool SelectionDAG::isKnownNeverNaN(SDValue Op, bool SNaN, unsigned Depth) const {
   }
   case ISD::FCANONICALIZE:
   case ISD::FEXP:
   case ISD::FEXP2:
   case ISD::FTRUNC:
   case ISD::FFLOOR:
   case ISD::FCEIL:
   case ISD::FROUND:
+  case ISD::FROUNDEVEN:
   case ISD::FRINT:
   case ISD::FNEARBYINT: {
     if (SNaN)
       return true;
     return isKnownNeverNaN(Op.getOperand(0), SNaN, Depth + 1);
   }
   case ISD::FABS:
   case ISD::FNEG:

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
   case Intrinsic::sin:
   case Intrinsic::cos:
   case Intrinsic::floor:
   case Intrinsic::ceil:
   case Intrinsic::trunc:
   case Intrinsic::rint:
   case Intrinsic::nearbyint:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::canonicalize: {
     unsigned Opcode;
     switch (Intrinsic) {
     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
     case Intrinsic::sqrt:      Opcode = ISD::FSQRT;      break;
     case Intrinsic::fabs:      Opcode = ISD::FABS;       break;
     case Intrinsic::sin:       Opcode = ISD::FSIN;       break;
     case Intrinsic::cos:       Opcode = ISD::FCOS;       break;
     case Intrinsic::floor:     Opcode = ISD::FFLOOR;     break;
     case Intrinsic::ceil:      Opcode = ISD::FCEIL;      break;
     case Intrinsic::trunc:     Opcode = ISD::FTRUNC;     break;
     case Intrinsic::rint:      Opcode = ISD::FRINT;      break;
     case Intrinsic::nearbyint: Opcode = ISD::FNEARBYINT; break;
     case Intrinsic::round:     Opcode = ISD::FROUND;     break;
+    case Intrinsic::roundeven: Opcode = ISD::FROUNDEVEN; break;
     case Intrinsic::canonicalize: Opcode = ISD::FCANONICALIZE; break;
     }
 
     setValue(&I, DAG.getNode(Opcode, sdl,
                              getValue(I.getArgOperand(0)).getValueType(),
                              getValue(I.getArgOperand(0))));
     return;
   }

llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

#endif
   case ISD::FCEIL:                      return "fceil";
   case ISD::STRICT_FCEIL:               return "strict_fceil";
   case ISD::FRINT:                      return "frint";
   case ISD::STRICT_FRINT:               return "strict_frint";
   case ISD::FNEARBYINT:                 return "fnearbyint";
   case ISD::STRICT_FNEARBYINT:          return "strict_fnearbyint";
   case ISD::FROUND:                     return "fround";
   case ISD::STRICT_FROUND:              return "strict_fround";
+  case ISD::FROUNDEVEN:                 return "froundeven";
+  case ISD::STRICT_FROUNDEVEN:          return "strict_froundeven";
   case ISD::FEXP:                       return "fexp";
   case ISD::STRICT_FEXP:                return "strict_fexp";
   case ISD::FEXP2:                      return "fexp2";
   case ISD::STRICT_FEXP2:               return "strict_fexp2";
   case ISD::FLOG:                       return "flog";
   case ISD::STRICT_FLOG:                return "strict_flog";
   case ISD::FLOG2:                      return "flog2";
   case ISD::STRICT_FLOG2:               return "strict_flog2";

llvm/lib/CodeGen/TargetLoweringBase.cpp

for (MVT VT : MVT::all_valuetypes()) {
     // These default to Expand so they will be expanded to CTLZ/CTTZ by default.
     setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
     setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
 
     setOperationAction(ISD::BITREVERSE, VT, Expand);
 
     // These library functions default to expand.
     setOperationAction(ISD::FROUND, VT, Expand);
+    setOperationAction(ISD::FROUNDEVEN, VT, Expand);
     setOperationAction(ISD::FPOWI, VT, Expand);
 
     // These operations default to expand for vector types.
     if (VT.isVector()) {
       setOperationAction(ISD::FCOPYSIGN, VT, Expand);
       setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
       setOperationAction(ISD::ANY_EXTEND_VECTOR_INREG, VT, Expand);
       setOperationAction(ISD::SIGN_EXTEND_VECTOR_INREG, VT, Expand);
for (MVT VT : {MVT::f32, MVT::f64, MVT::f128}) {
     setOperationAction(ISD::FEXP ,      VT, Expand);
     setOperationAction(ISD::FEXP2,      VT, Expand);
     setOperationAction(ISD::FFLOOR,     VT, Expand);
     setOperationAction(ISD::FNEARBYINT, VT, Expand);
     setOperationAction(ISD::FCEIL,      VT, Expand);
     setOperationAction(ISD::FRINT,      VT, Expand);
     setOperationAction(ISD::FTRUNC,     VT, Expand);
     setOperationAction(ISD::FROUND,     VT, Expand);
+    setOperationAction(ISD::FROUNDEVEN, VT, Expand);
     setOperationAction(ISD::LROUND,     VT, Expand);
     setOperationAction(ISD::LLROUND,    VT, Expand);
     setOperationAction(ISD::LRINT,      VT, Expand);
     setOperationAction(ISD::LLRINT,     VT, Expand);
   }
 
   // Default ISD::TRAP to expand (which turns it into abort).
   setOperationAction(ISD::TRAP, MVT::Other, Expand);

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (match(II->getArgOperand(0),
       return SelectInst::Create(Cond, Call0, Call1);
     }
 
     LLVM_FALLTHROUGH;
   }
   case Intrinsic::ceil:
   case Intrinsic::floor:
   case Intrinsic::round:
+  case Intrinsic::roundeven:
   case Intrinsic::nearbyint:
   case Intrinsic::rint:
   case Intrinsic::trunc: {
     Value *ExtSrc;
     if (match(II->getArgOperand(0), m_OneUse(m_FPExt(m_Value(ExtSrc))))) {
       // Narrow the call: intrinsic (fpext x) -> fpext (intrinsic x)
       Value *NarrowII = Builder.CreateUnaryIntrinsic(IID, ExtSrc, II);
       return new FPExtInst(NarrowII, II->getType());

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

if (auto *II = dyn_cast<IntrinsicInst>(FPT.getOperand(0))) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::ceil:
     case Intrinsic::fabs:
     case Intrinsic::floor:
     case Intrinsic::nearbyint:
     case Intrinsic::rint:
     case Intrinsic::round:
+    case Intrinsic::roundeven:
     case Intrinsic::trunc: {
       Value *Src = II->getArgOperand(0);
       if (!Src->hasOneUse())
         break;
 
       // Except for fabs, this transformation requires the input of the unary FP
       // operation to be itself an fpext from the type to which we're
       // truncating.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeFloatingPointLibCall(CallInst *CI,
   case LibFunc_tanl:
     return optimizeTan(CI, Builder);
   case LibFunc_ceil:
     return replaceUnaryCall(CI, Builder, Intrinsic::ceil);
   case LibFunc_floor:
     return replaceUnaryCall(CI, Builder, Intrinsic::floor);
   case LibFunc_round:
     return replaceUnaryCall(CI, Builder, Intrinsic::round);
+  case LibFunc_roundeven:
+    return replaceUnaryCall(CI, Builder, Intrinsic::roundeven);
   case LibFunc_nearbyint:
     return replaceUnaryCall(CI, Builder, Intrinsic::nearbyint);
   case LibFunc_rint:
     return replaceUnaryCall(CI, Builder, Intrinsic::rint);
   case LibFunc_trunc:
     return replaceUnaryCall(CI, Builder, Intrinsic::trunc);
   case LibFunc_acos:
   case LibFunc_acosh:

llvm/test/CodeGen/Generic/fpoperations.ll

+; RUN: llc < %s | FileCheck %s
+
+; This test checks default lowering of the intrinsics operating floating point
+; values. MSP430 is used as a target in this test because it does not have
+; native FP support, so it won't get custom lowering for these intrinsics.
+;
+; REQUIRES: msp430-registered-target
+
+target datalayout = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16"
+target triple = "msp430---elf"
+
+
+define float @roundeven_01(float %x) {
+entry:
+  %res = call float @llvm.roundeven.f32(float %x)
+  ret float %res
+}
+; CHECK-LABEL: roundeven_01:
+; CHECK: call #roundeven
+
+declare float @llvm.roundeven.f32(float %x)

llvm/test/ExecutionEngine/Interpreter/intrinsics.ll

 ; RUN: lli -O0 -force-interpreter < %s
 
 ; libffi does not support fp128 so we don’t test it
 declare float  @llvm.sin.f32(float)
 declare double @llvm.sin.f64(double)
 declare float  @llvm.cos.f32(float)
 declare double @llvm.cos.f64(double)
 declare float  @llvm.floor.f32(float)
 declare double @llvm.floor.f64(double)
 declare float  @llvm.ceil.f32(float)
 declare double @llvm.ceil.f64(double)
 declare float  @llvm.trunc.f32(float)
 declare double @llvm.trunc.f64(double)
 declare float  @llvm.round.f32(float)
 declare double @llvm.round.f64(double)
+declare float  @llvm.roundeven.f32(float)
+declare double @llvm.roundeven.f64(double)
 declare float  @llvm.copysign.f32(float, float)
 declare double @llvm.copysign.f64(double, double)
 
 define i32 @main() {
   %sin32 = call float @llvm.sin.f32(float 0.000000e+00)
   %sin64 = call double @llvm.sin.f64(double 0.000000e+00)
   %cos32 = call float @llvm.cos.f32(float 0.000000e+00)
   %cos64 = call double @llvm.cos.f64(double 0.000000e+00)
   %floor32 = call float @llvm.floor.f32(float 0.000000e+00)
   %floor64 = call double @llvm.floor.f64(double 0.000000e+00)
   %ceil32 = call float @llvm.ceil.f32(float 0.000000e+00)
   %ceil64 = call double @llvm.ceil.f64(double 0.000000e+00)
   %trunc32 = call float @llvm.trunc.f32(float 0.000000e+00)
   %trunc64 = call double @llvm.trunc.f64(double 0.000000e+00)
   %round32 = call float @llvm.round.f32(float 0.000000e+00)
   %round64 = call double @llvm.round.f64(double 0.000000e+00)
+  %roundeven32 = call float @llvm.roundeven.f32(float 0.000000e+00)
+  %roundeven64 = call double @llvm.roundeven.f64(double 0.000000e+00)
   %copysign32 = call float @llvm.copysign.f32(float 0.000000e+00, float 0.000000e+00)
   %copysign64 = call double @llvm.copysign.f64(double 0.000000e+00, double 0.000000e+00)
   ret i32 0
 }

llvm/test/Transforms/InstCombine/double-float-shrink-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux"     | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32"     | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32"   | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32"   | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck %s
 ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s
 
 declare double @floor(double)
 declare double @ceil(double)
 declare double @round(double)
+declare double @roundeven(double)
 declare double @nearbyint(double)
 declare double @trunc(double)
 declare double @fabs(double)
 
 declare double @llvm.ceil.f64(double)
 declare <2 x double> @llvm.ceil.v2f64(<2 x double>)
 
 declare double @llvm.fabs.f64(double)
 declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
 
 declare double @llvm.floor.f64(double)
 declare <2 x double> @llvm.floor.v2f64(<2 x double>)
 
 declare double @llvm.nearbyint.f64(double)
 declare <2 x double> @llvm.nearbyint.v2f64(<2 x double>)
 
 declare float @llvm.rint.f32(float)
 declare <2 x float> @llvm.rint.v2f32(<2 x float>)
 
 declare double @llvm.round.f64(double)
 declare <2 x double> @llvm.round.v2f64(<2 x double>)
 
+declare double @llvm.roundeven.f64(double)
+declare <2 x double> @llvm.roundeven.v2f64(<2 x double>)
+
 declare double @llvm.trunc.f64(double)
 declare <2 x double> @llvm.trunc.v2f64(<2 x double>)
 
 define float @test_shrink_libcall_floor(float %C) {
 ; CHECK-LABEL: @test_shrink_libcall_floor(
 ; CHECK-NEXT:    [[F:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
 ; CHECK-NEXT:    ret float [[F]]
 ;

 ;
   %D = fpext float %C to double
   ; --> roundf
   %E = call double @round(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
+define float @test_shrink_libcall_roundeven(float %C) {
+; CHECK-LABEL: @test_shrink_libcall_roundeven(
+; CHECK-NEXT:    [[F:%.*]] = call float @llvm.roundeven.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[F]]
+;
+  %D = fpext float %C to double
+  ; --> roundeven
+  %E = call double @roundeven(double %D)
+  %F = fptrunc double %E to float
+  ret float %F
+}
+
 define float @test_shrink_libcall_nearbyint(float %C) {
 ; CHECK-LABEL: @test_shrink_libcall_nearbyint(
 ; CHECK-NEXT:    [[F:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
 ; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext float %C to double
   ; --> nearbyintf
   %E = call double @nearbyint(double %D)

 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
+define float @test_shrink_intrin_roundeven(float %C) {
+; CHECK-LABEL: @test_shrink_intrin_roundeven(
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.roundeven.f32(float [[C:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %D = fpext float %C to double
+  %E = call double @llvm.roundeven.f64(double %D)
+  %F = fptrunc double %E to float
+  ret float %F
+}
+
 define float @test_shrink_intrin_trunc(float %C) {
 ; CHECK-LABEL: @test_shrink_intrin_trunc(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %D = fpext float %C to double
   %E = call double @llvm.trunc.f64(double %D)
   %F = fptrunc double %E to float
;
   %D = fpext <2 x float> %C to <2 x double>
   %E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
   %F = fptrunc <2 x double> %E to <2 x float>
   call void @use_v2f64(<2 x double> %D)
   call void @use_v2f64(<2 x double> %E)
   ret <2 x float> %F
 }
 
+define <2 x float> @test_shrink_intrin_roundeven_multi_use(<2 x float> %C) {
+; CHECK-LABEL: @test_shrink_intrin_roundeven_multi_use(
+; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
+; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.roundeven.v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
+; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[E]])
+; CHECK-NEXT:    ret <2 x float> [[F]]
+;
+  %D = fpext <2 x float> %C to <2 x double>
+  %E = call <2 x double> @llvm.roundeven.v2f64(<2 x double> %D)
+  %F = fptrunc <2 x double> %E to <2 x float>
+  call void @use_v2f64(<2 x double> %D)
+  call void @use_v2f64(<2 x double> %E)
+  ret <2 x float> %F
+}
+
 define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) {
 ; CHECK-LABEL: @test_shrink_intrin_trunc_multi_use(
 ; CHECK-NEXT:    [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
 ; CHECK-NEXT:    [[E:%.*]] = call <2 x double> @llvm.trunc.v2f64(<2 x double> [[D]])
 ; CHECK-NEXT:    [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
 ; CHECK-NEXT:    call void @use_v2f64(<2 x double> [[D]])
 ; CHECK-NEXT:    ret <2 x float> [[F]]
 ;

 ; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
 ; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
+define float @test_no_shrink_intrin_roundeven(double %D) {
+; CHECK-LABEL: @test_no_shrink_intrin_roundeven(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.roundeven.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
+; CHECK-NEXT:    ret float [[F]]
+;
+  %E = call double @llvm.roundeven.f64(double %D)
+  %F = fptrunc double %E to float
+  ret float %F
+}
+
 define float @test_no_shrink_intrin_nearbyint(double %D) {
 ; CHECK-LABEL: @test_no_shrink_intrin_nearbyint(
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
 ; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to float
 ; CHECK-NEXT:    ret float [[F]]
 ;
   %E = call double @llvm.nearbyint.f64(double %D)
   %F = fptrunc double %E to float

 ; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_round(
 ; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.round.f64(double 2.1)
   %F = fptrunc double %E to float
   ret float %F
 }
 
+define float @test_shrink_float_convertible_constant_intrin_roundeven() {
+; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_roundeven(
+; CHECK-NEXT:    ret float 2.000000e+00
+;
+  %E = call double @llvm.roundeven.f64(double 2.1)
+  %F = fptrunc double %E to float
+  ret float %F
+}
+
 define float @test_shrink_float_convertible_constant_intrin_nearbyint() {
 ; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_nearbyint(
 ; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %E = call double @llvm.nearbyint.f64(double 2.1)
   %F = fptrunc double %E to float
   ret float %F
 }

 ; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
 ; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to half
   ret half %F
 }
 
+define half @test_no_shrink_mismatched_type_intrin_roundeven(double %D) {
+; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_roundeven(
+; CHECK-NEXT:    [[E:%.*]] = call double @llvm.roundeven.f64(double [[D:%.*]])
+; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
+; CHECK-NEXT:    ret half [[F]]
+;
+  %E = call double @llvm.roundeven.f64(double %D)
+  %F = fptrunc double %E to half
+  ret half %F
+}
+
 define half @test_no_shrink_mismatched_type_intrin_nearbyint(double %D) {
 ; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_nearbyint(
 ; CHECK-NEXT:    [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
 ; CHECK-NEXT:    [[F:%.*]] = fptrunc double [[E]] to half
 ; CHECK-NEXT:    ret half [[F]]
 ;
   %E = call double @llvm.nearbyint.f64(double %D)
   %F = fptrunc double %E to half

 ; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
 ; CHECK-NEXT:    ret <2 x double> [[E]]
 ;
   %D = fpext <2 x  half> %C to <2 x double>
   %E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
   ret <2 x double> %E
 }
 
+define <2 x double> @test_shrink_intrin_roundeven_fp16_vec(<2 x half> %C) {
+; CHECK-LABEL: @test_shrink_intrin_roundeven_fp16_vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.roundeven.v2f16(<2 x half> [[C:%.*]])
+; CHECK-NEXT:    [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
+; CHECK-NEXT:    ret <2 x double> [[E]]
+;
+  %D = fpext <2 x  half> %C to <2 x double>
+  %E = call <2 x double> @llvm.roundeven.v2f64(<2 x double> %D)
+  ret <2 x double> %E
+}
+
 define float @test_shrink_intrin_nearbyint_fp16_src(half %C) {
 ; CHECK-LABEL: @test_shrink_intrin_nearbyint_fp16_src(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.nearbyint.f16(half [[C:%.*]])
 ; CHECK-NEXT:    [[F:%.*]] = fpext half [[TMP1]] to float
 ; CHECK-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.nearbyint.f64(double %D)

llvm/test/Transforms/InstCombine/float-shrink-compare.ll

 ;
   %x.ext = fpext float %x to double
   %round = call double @llvm.round.f64(double %x.ext) nounwind readnone
   %y.ext = fpext float %y to double
   %cmp = fcmp oeq double %round, %y.ext
   ret i1 %cmp
 }
 
+define i1 @test6a(float %x, float %y) {
+; CHECK-LABEL: @test6a(
+; CHECK-NEXT:    [[ROUND:%.*]] = call float @llvm.roundeven.f32(float %x)
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[ROUND]], %y
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %x.ext = fpext float %x to double
+  %round = call double @roundeven(double %x.ext) nounwind readnone
+  %y.ext = fpext float %y to double
+  %cmp = fcmp oeq double %round, %y.ext
+  ret i1 %cmp
+}
+
+define i1 @test6a_intrin(float %x, float %y) {
+; CHECK-LABEL: @test6a_intrin(
+; CHECK-NEXT:    [[ROUND:%.*]] = call float @llvm.roundeven.f32(float %x)
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[ROUND]], %y
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %x.ext = fpext float %x to double
+  %round = call double @llvm.roundeven.f64(double %x.ext) nounwind readnone
+  %y.ext = fpext float %y to double
+  %cmp = fcmp oeq double %round, %y.ext
+  ret i1 %cmp
+}
+
 define i1 @test7(float %x, float %y) {
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:    [[TRUNC:%.*]] = call float @llvm.trunc.f32(float %x)
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[TRUNC]], %y
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %x.ext = fpext float %x to double
   %trunc = call double @trunc(double %x.ext) nounwind

 ;
   %x.ext = fpext float %x to double
   %y.ext = fpext float %y to double
   %round = call double @llvm.round.f64(double %x.ext) nounwind readnone
   %cmp = fcmp oeq double %y.ext, %round
   ret i1 %cmp
 }
 
+define i1 @test13a(float %x, float %y) {
+; CHECK-LABEL: @test13a(
+; CHECK-NEXT:    [[ROUND:%.*]] = call float @llvm.roundeven.f32(float %x)
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[ROUND]], %y
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %round = call double @roundeven(double %x.ext) nounwind readnone
+  %cmp = fcmp oeq double %y.ext, %round
+  ret i1 %cmp
+}
+
+define i1 @test13a_intrin(float %x, float %y) {
+; CHECK-LABEL: @test13a_intrin(
+; CHECK-NEXT:    [[ROUND:%.*]] = call float @llvm.roundeven.f32(float %x)
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[ROUND]], %y
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %round = call double @llvm.roundeven.f64(double %x.ext) nounwind readnone
+  %cmp = fcmp oeq double %y.ext, %round
+  ret i1 %cmp
+}
+
 define i1 @test14(float %x, float %y) {
 ; CHECK-LABEL: @test14(
 ; CHECK-NEXT:    [[TRUNC:%.*]] = call float @llvm.trunc.f32(float %x)
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float [[TRUNC]], %y
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %x.ext = fpext float %x to double
   %y.ext = fpext float %y to double

 
 declare double @fabs(double) nounwind readnone
 declare double @ceil(double) nounwind readnone
 declare double @copysign(double, double) nounwind readnone
 declare double @floor(double) nounwind readnone
 declare double @nearbyint(double) nounwind readnone
 declare double @rint(double) nounwind readnone
 declare double @round(double) nounwind readnone
+declare double @roundeven(double) nounwind readnone
 declare double @trunc(double) nounwind readnone
 declare double @fmin(double, double) nounwind readnone
 declare double @fmax(double, double) nounwind readnone
 
 declare double @llvm.fabs.f64(double) nounwind readnone
 declare double @llvm.ceil.f64(double) nounwind readnone
 declare double @llvm.floor.f64(double) nounwind readnone
 declare double @llvm.nearbyint.f64(double) nounwind readnone
 declare double @llvm.round.f64(double) nounwind readnone
+declare double @llvm.roundeven.f64(double) nounwind readnone
 declare double @llvm.trunc.f64(double) nounwind readnone

llvm/test/Transforms/InstSimplify/known-never-nan.ll

 ; CHECK-NEXT:    ret i1 false
 ;
   %nnan = fadd nnan double %arg, 1.0
   %op = call double @llvm.round.f64(double %nnan)
   %tmp = fcmp uno double %op, %op
   ret i1 %tmp
 }
 
+define i1 @roundeven_nnan_src(double %arg) {
+; CHECK-LABEL: @roundeven_nnan_src(
+; CHECK-NEXT:    ret i1 false
+;
+  %nnan = fadd nnan double %arg, 1.0
+  %op = call double @llvm.roundeven.f64(double %nnan)
+  %tmp = fcmp uno double %op, %op
+  ret i1 %tmp
+}
+
 define i1 @known_nan_select(i1 %cond, double %arg0, double %arg1) {
 ; CHECK-LABEL: @known_nan_select(
 ; CHECK-NEXT:    ret i1 true
 ;
   %lhs = fadd nnan double %arg0, 1.0
   %rhs = fadd nnan double %arg1, 2.0
   %op = select i1 %cond, double %lhs, double %rhs
   %tmp = fcmp ord double %op, %op

 declare double @llvm.exp.f64(double)
 declare double @llvm.exp2.f64(double)
 declare double @llvm.floor.f64(double)
 declare double @llvm.ceil.f64(double)
 declare double @llvm.trunc.f64(double)
 declare double @llvm.rint.f64(double)
 declare double @llvm.nearbyint.f64(double)
 declare double @llvm.round.f64(double)
+declare double @llvm.roundeven.f64(double)

llvm/test/Transforms/InstSimplify/round-intrinsics.ll

 ; CHECK-NEXT:    [[CVT:%.*]] = uitofp i32 [[ARG:%.*]] to float
 ; CHECK-NEXT:    ret float [[CVT]]
 ;
   %cvt = uitofp i32 %arg to float
   %round = call float @llvm.round.f32(float %cvt)
   ret float %round
 }
 
+define float @uitofp_roundeven(i32 %arg) {
+; CHECK-LABEL: @uitofp_roundeven(
+; CHECK-NEXT:    [[CVT:%.*]] = uitofp i32 [[ARG:%.*]] to float
+; CHECK-NEXT:    ret float [[CVT]]
+;
+  %cvt = uitofp i32 %arg to float
+  %round = call float @llvm.roundeven.f32(float %cvt)
+  ret float %round
+}
+
 define float @sitofp_nearbyint(i32 %arg) {
 ; CHECK-LABEL: @sitofp_nearbyint(
 ; CHECK-NEXT:    [[CVT:%.*]] = sitofp i32 [[ARG:%.*]] to float
 ; CHECK-NEXT:    ret float [[CVT]]
 ;
   %cvt = sitofp i32 %arg to float
   %nearbyint = call float @llvm.nearbyint.f32(float %cvt)
   ret float %nearbyint
;
   %rint = call float @llvm.rint.f32(float %cvt)
   ret float %rint
 }
 
 declare float @llvm.floor.f32(float) #0
 declare float @llvm.trunc.f32(float) #0
 declare float @llvm.ceil.f32(float) #0
 declare float @llvm.round.f32(float) #0
+declare float @llvm.roundeven.f32(float) #0
 declare float @llvm.nearbyint.f32(float) #0
 declare float @llvm.rint.f32(float) #0
 
 attributes #0 = { nounwind readnone speculatable }

llvm/test/Transforms/LICM/hoist-round.ll

 ; CHECK: call float @llvm.rint.f32
 ; CHECK: call float @llvm.round.f32
 ; CHECK: call float @llvm.trunc.f32
 ; CHECK: call float @llvm.fabs.f32
 ; CHECK: call float @llvm.copysign.f32
 ; CHECK: call float @llvm.minnum.f32
 ; CHECK: call float @llvm.maxnum.f32
 ; CHECK: call float @llvm.powi.f32
+; CHECK: call float @llvm.roundeven.f32
 ; CHECK: for.body:
 
 define void @test(float %arg1, float %arg2) {
 entry:
   br label %for.head
 
 for.head:
   %IND = phi i32 [ 0, %entry ], [ %IND.new, %for.body ]
for.body:
   %tmp.6 = call float @llvm.trunc.f32(float %tmp.5)
   %tmp.7 = call float @llvm.fabs.f32(float %tmp.6)
   %tmp.8 = call float @llvm.copysign.f32(float %tmp.7, float %arg2)
   %tmp.9 = call float @llvm.minnum.f32(float %tmp.8, float %arg2)
   %tmp.10 = call float @llvm.maxnum.f32(float %tmp.9, float %arg2)
   %tmp.11 = call float @llvm.minimum.f32(float %tmp.10, float %arg2)
   %tmp.12 = call float @llvm.maximum.f32(float %tmp.11, float %arg2)
   %tmp.13 = call float @llvm.powi.f32(float %tmp.12, i32 4)
-  call void @consume(float %tmp.13)
+  %tmp.14 = call float @llvm.roundeven.f32(float %tmp.13)
+  call void @consume(float %tmp.14)
   %IND.new = add i32 %IND, 1
   br label %for.head
 
 exit:
   ret void
 }
 
 declare void @consume(float)
 
 declare float @llvm.ceil.f32(float)
 declare float @llvm.floor.f32(float)
 declare float @llvm.nearbyint.f32(float)
 declare float @llvm.rint.f32(float)
 declare float @llvm.round.f32(float)
 declare float @llvm.trunc.f32(float)
 declare float @llvm.fabs.f32(float)
 declare float @llvm.copysign.f32(float, float)
 declare float @llvm.minnum.f32(float, float)
 declare float @llvm.maxnum.f32(float, float)
 declare float @llvm.minimum.f32(float, float)
 declare float @llvm.maximum.f32(float, float)
 declare float @llvm.powi.f32(float, i32)
+declare float @llvm.roundeven.f32(float)

llvm/test/Transforms/LoopVectorize/intrinsic.ll

for.body:                                         ; preds = %entry, %for.body
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body, %entry
   ret void
 }
 
 declare double @llvm.round.f64(double) nounwind readnone
 
+;CHECK-LABEL: @roundeven_f32(
+;CHECK: llvm.roundeven.v4f32
+;CHECK: ret void
+define void @roundeven_f32(i32 %n, float* noalias %y, float* noalias %x) nounwind uwtable {
+entry:
+  %cmp6 = icmp sgt i32 %n, 0
+  br i1 %cmp6, label %for.body, label %for.end
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
+  %arrayidx = getelementptr inbounds float, float* %y, i64 %indvars.iv
+  %0 = load float, float* %arrayidx, align 4
+  %call = tail call float @llvm.roundeven.f32(float %0) nounwind readnone
+  %arrayidx2 = getelementptr inbounds float, float* %x, i64 %indvars.iv
+  store float %call, float* %arrayidx2, align 4
+  %indvars.iv.next = add i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %n
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body, %entry
+  ret void
+}
+
+declare float @llvm.roundeven.f32(float) nounwind readnone
+
+;CHECK-LABEL: @roundeven_f64(
+;CHECK: llvm.roundeven.v4f64
+;CHECK: ret void
+define void @roundeven_f64(i32 %n, double* noalias %y, double* noalias %x) nounwind uwtable {
+entry:
+  %cmp6 = icmp sgt i32 %n, 0
+  br i1 %cmp6, label %for.body, label %for.end
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
+  %arrayidx = getelementptr inbounds double, double* %y, i64 %indvars.iv
+  %0 = load double, double* %arrayidx, align 8
+  %call = tail call double @llvm.roundeven.f64(double %0) nounwind readnone
+  %arrayidx2 = getelementptr inbounds double, double* %x, i64 %indvars.iv
+  store double %call, double* %arrayidx2, align 8
+  %indvars.iv.next = add i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %n
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body, %entry
+  ret void
+}
+
+declare double @llvm.roundeven.f64(double) nounwind readnone
+
 ;CHECK-LABEL: @fma_f32(
 ;CHECK: llvm.fma.v4f32
 ;CHECK: ret void
 define void @fma_f32(i32 %n, float* noalias %y, float* noalias %x, float* noalias %z, float* noalias %w) nounwind uwtable {
 entry:
   %cmp12 = icmp sgt i32 %n, 0
   br i1 %cmp12, label %for.body, label %for.end
 

llvm/unittests/Analysis/TargetLibraryInfoTest.cpp

parseAssembly(
       "declare void @rewind(%struct*)\n"
       "declare double @rint(double)\n"
       "declare float @rintf(float)\n"
       "declare x86_fp80 @rintl(x86_fp80)\n"
       "declare i32 @rmdir(i8*)\n"
       "declare double @round(double)\n"
       "declare float @roundf(float)\n"
       "declare x86_fp80 @roundl(x86_fp80)\n"
+      "declare double @roundeven(double)\n"
+      "declare float @roundevenf(float)\n"
+      "declare x86_fp80 @roundevenl(x86_fp80)\n"
       "declare i32 @scanf(i8*, ...)\n"
       "declare void @setbuf(%struct*, i8*)\n"
       "declare i32 @setitimer(i32, %struct*, %struct*)\n"
       "declare i32 @setvbuf(%struct*, i8*, i32, i64)\n"
       "declare double @sin(double)\n"
       "declare float @sinf(float)\n"
       "declare double @sinh(double)\n"
       "declare float @sinhf(float)\n"
parseAssembly(
       "declare float @exp10f(float)\n"
       "declare x86_fp80 @exp10l(x86_fp80)\n"
 
       // These printf variants have the same prototype as the non-'i' versions.
       "declare i32 @fiprintf(%struct*, i8*, ...)\n"
       "declare i32 @iprintf(i8*, ...)\n"
       "declare i32 @siprintf(i8*, i8*, ...)\n"
 
       // __small_printf variants have the same prototype as the non-'i' versions.
       "declare i32 @__small_fprintf(%struct*, i8*, ...)\n"
       "declare i32 @__small_printf(i8*, ...)\n"
       "declare i32 @__small_sprintf(i8*, i8*, ...)\n"
 
       "declare i32 @htonl(i32)\n"
       "declare i16 @htons(i16)\n"
       "declare i32 @ntohl(i32)\n"
       "declare i16 @ntohs(i16)\n"
parseAssembly(
       "declare double @__log_finite(double)\n"
       "declare float @__logf_finite(float)\n"
       "declare x86_fp80 @__logl_finite(x86_fp80)\n"
       "declare double @__pow_finite(double, double)\n"
       "declare float @__powf_finite(float, float)\n"
       "declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)\n"
       "declare double @__sinh_finite(double)\n"
       "declare float @__sinhf_finite(float)\n"
       "declare x86_fp80 @__sinhl_finite(x86_fp80)\n"
       );
 
   for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
     LibFunc LF = (LibFunc)FI;
     // Make sure everything is available; we're not testing target defaults.
     TLII.setAvailable(LF);
     Function *F = M->getFunction(TLI.getName(LF));
     EXPECT_TRUE(isLibFunc(F, LF));
   }
 }

llvm/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, Intrinsics) {
   EXPECT_TRUE(II->hasNoInfs());
   EXPECT_FALSE(II->hasNoNaNs());
 
   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
   II = cast<IntrinsicInst>(Call);
   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
   EXPECT_TRUE(II->hasNoInfs());
   EXPECT_FALSE(II->hasNoNaNs());
+
+  Call = Builder.CreateUnaryIntrinsic(Intrinsic::roundeven, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::roundeven);
+  EXPECT_FALSE(II->hasNoInfs());
+  EXPECT_FALSE(II->hasNoNaNs());
 }
 
 TEST_F(IRBuilderTest, IntrinsicsWithScalableVectors) {
   IRBuilder<> Builder(BB);
   CallInst *Call;
   FunctionType *FTy;
 
   // Test scalable flag isn't dropped for intrinsic that is explicitly defined
TEST_F(IRBuilderTest, ConstrainedFP) {
   EXPECT_EQ(CII->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
   EXPECT_EQ(fp::ebMayTrap, CII->getExceptionBehavior());
   EXPECT_EQ(RoundingMode::TowardNegative, CII->getRoundingMode());
 
   Builder.CreateRetVoid();
   EXPECT_FALSE(verifyModule(*M));
 }
 
+TEST_F(IRBuilderTest, ConstrainedFPIntrinsics) {
+  IRBuilder<> Builder(BB);
+  Value *V;
+  Value *VDouble;
+  ConstrainedFPIntrinsic *CII;
+  GlobalVariable *GVDouble = new GlobalVariable(
+      *M, Type::getDoubleTy(Ctx), true, GlobalValue::ExternalLinkage, nullptr);
+  VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
+
+  Builder.setDefaultConstrainedExcept(fp::ebStrict);
+  Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
+  Function *Fn = Intrinsic::getDeclaration(M.get(),
+      Intrinsic::experimental_constrained_roundeven, { Type::getDoubleTy(Ctx) });
+  V = Builder.CreateConstrainedFPCall(Fn, { VDouble });
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  EXPECT_EQ(Intrinsic::experimental_constrained_roundeven, CII->getIntrinsicID());
+  EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
+}
+
 TEST_F(IRBuilderTest, Lifetime) {
   IRBuilder<> Builder(BB);
   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
                                           Builder.getInt32(123));
 
   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);