[WebAssembly] Add lowering for llvm.rint and llvm.roundeven

[dschuff]

Thanks!

[xortoast]

@dschuff What's the next step to get this merged?

[dschuff]

If you're not an LLVM committer, I can merge it for you.

[xortoast]

In D153451#4444389, @dschuff wrote:

If you're not an LLVM committer, I can merge it for you.

I am not. Please commit this as "xortoast <[e-mail]>".

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

for (auto CC : {ISD::SETO, ISD::SETUO, ISD::SETUEQ, ISD::SETONE,
                     ISD::SETULT, ISD::SETULE, ISD::SETUGT, ISD::SETUGE})
       setCondCodeAction(CC, T, Expand);
     // Expand floating-point library function operators.
     for (auto Op :
          {ISD::FSIN, ISD::FCOS, ISD::FSINCOS, ISD::FPOW, ISD::FREM, ISD::FMA})
       setOperationAction(Op, T, Expand);
     // Note supported floating-point library function operators that otherwise
     // default to expand.
-    for (auto Op :
-         {ISD::FCEIL, ISD::FFLOOR, ISD::FTRUNC, ISD::FNEARBYINT, ISD::FRINT})
+    for (auto Op : {ISD::FCEIL, ISD::FFLOOR, ISD::FTRUNC, ISD::FNEARBYINT,
+                    ISD::FRINT, ISD::FROUNDEVEN})
       setOperationAction(Op, T, Legal);
     // Support minimum and maximum, which otherwise default to expand.
     setOperationAction(ISD::FMINIMUM, T, Legal);
     setOperationAction(ISD::FMAXIMUM, T, Legal);
     // WebAssembly currently has no builtin f16 support.
     setOperationAction(ISD::FP16_TO_FP, T, Expand);
     setOperationAction(ISD::FP_TO_FP16, T, Expand);
     setLoadExtAction(ISD::EXTLOAD, T, MVT::f16, Expand);
if (Subtarget->hasSIMD128()) {
 
     // Custom lower bit counting operations for other types to scalarize them.
     for (auto Op : {ISD::CTLZ, ISD::CTTZ, ISD::CTPOP})
       for (auto T : {MVT::v8i16, MVT::v4i32, MVT::v2i64})
         setOperationAction(Op, T, Custom);
 
     // Expand float operations supported for scalars but not SIMD
     for (auto Op : {ISD::FCOPYSIGN, ISD::FLOG, ISD::FLOG2, ISD::FLOG10,
-                    ISD::FEXP, ISD::FEXP2, ISD::FRINT})
+                    ISD::FEXP, ISD::FEXP2})
       for (auto T : {MVT::v4f32, MVT::v2f64})
         setOperationAction(Op, T, Expand);
 
     // Unsigned comparison operations are unavailable for i64x2 vectors.
     for (auto CC : {ISD::SETUGT, ISD::SETUGE, ISD::SETULT, ISD::SETULE})
       setCondCodeAction(CC, MVT::v2i64, Custom);
 
     // 64x2 conversions are not in the spec

llvm/lib/Target/WebAssembly/WebAssemblyInstrFloat.td

def : Pat<(fcopysign F64:$lhs, F32:$rhs),
           (COPYSIGN_F64 F64:$lhs, (F64_PROMOTE_F32 F32:$rhs))>;
 def : Pat<(fcopysign F32:$lhs, F64:$rhs),
           (COPYSIGN_F32 F32:$lhs, (F32_DEMOTE_F64 F64:$rhs))>;
 
 // WebAssembly doesn't expose inexact exceptions, so map frint to fnearbyint.
 def : Pat<(frint f32:$src), (NEAREST_F32 f32:$src)>;
 def : Pat<(frint f64:$src), (NEAREST_F64 f64:$src)>;
 
+// WebAssembly always rounds ties-to-even, so map froundeven to fnearbyint.
+def : Pat<(froundeven f32:$src), (NEAREST_F32 f32:$src)>;
+def : Pat<(froundeven f64:$src), (NEAREST_F64 f64:$src)>;
+
 let isCommutable = 1 in {
 defm EQ : ComparisonFP<SETOEQ, "eq  ", 0x5b, 0x61>;
 defm NE : ComparisonFP<SETUNE, "ne  ", 0x5c, 0x62>;
 } // isCommutable = 1
 defm LT : ComparisonFP<SETOLT, "lt  ", 0x5d, 0x63>;
 defm LE : ComparisonFP<SETOLE, "le  ", 0x5f, 0x65>;
 defm GT : ComparisonFP<SETOGT, "gt  ", 0x5e, 0x64>;
 defm GE : ComparisonFP<SETOGE, "ge  ", 0x60, 0x66>;

llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td

 defm FLOOR : SIMDUnary<F32x4, ffloor, "floor", 0x68>;
 defm TRUNC: SIMDUnary<F32x4, ftrunc, "trunc", 0x69>;
 defm NEAREST: SIMDUnary<F32x4, fnearbyint, "nearest", 0x6a>;
 defm CEIL : SIMDUnary<F64x2, fceil, "ceil", 0x74>;
 defm FLOOR : SIMDUnary<F64x2, ffloor, "floor", 0x75>;
 defm TRUNC: SIMDUnary<F64x2, ftrunc, "trunc", 0x7a>;
 defm NEAREST: SIMDUnary<F64x2, fnearbyint, "nearest", 0x94>;
 
+// WebAssembly doesn't expose inexact exceptions, so map frint to fnearbyint.
+def : Pat<(v4f32 (frint (v4f32 V128:$src))), (NEAREST_F32x4 V128:$src)>;
+def : Pat<(v2f64 (frint (v2f64 V128:$src))), (NEAREST_F64x2 V128:$src)>;
+
+// WebAssembly always rounds ties-to-even, so map froundeven to fnearbyint.
+def : Pat<(v4f32 (froundeven (v4f32 V128:$src))), (NEAREST_F32x4 V128:$src)>;
+def : Pat<(v2f64 (froundeven (v2f64 V128:$src))), (NEAREST_F64x2 V128:$src)>;
+
 //===----------------------------------------------------------------------===//
 // Floating-point binary arithmetic
 //===----------------------------------------------------------------------===//
 
 multiclass SIMDBinaryFP<SDPatternOperator node, string name, bits<32> baseInst> {
   defm "" : SIMDBinary<F32x4, node, name, baseInst>;
   defm "" : SIMDBinary<F64x2, node, name, !add(baseInst, 12)>;
 }

llvm/test/CodeGen/WebAssembly/f32.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s
 
 ; Test that basic 32-bit floating-point operations assemble as expected.
 
 target triple = "wasm32-unknown-unknown"
 
 declare float @llvm.fabs.f32(float)
 declare float @llvm.copysign.f32(float, float)
 declare float @llvm.sqrt.f32(float)
 declare float @llvm.ceil.f32(float)
 declare float @llvm.floor.f32(float)
 declare float @llvm.trunc.f32(float)
 declare float @llvm.nearbyint.f32(float)
 declare float @llvm.rint.f32(float)
+declare float @llvm.roundeven.f32(float)
 declare float @llvm.fma.f32(float, float, float)
 
 define float @fadd32(float %x, float %y) {
 ; CHECK-LABEL: fadd32:
 ; CHECK:         .functype fadd32 (f32, f32) -> (f32)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get $push2=, 0
 ; CHECK-NEXT:    local.get $push1=, 1

 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get $push1=, 0
 ; CHECK-NEXT:    f32.nearest $push0=, $pop1
 ; CHECK-NEXT:    return $pop0
   %a = call float @llvm.rint.f32(float %x)
   ret float %a
 }
 
+define float @nearest32_via_roundeven(float %x) {
+; CHECK-LABEL: nearest32_via_roundeven:
+; CHECK:         .functype nearest32_via_roundeven (f32) -> (f32)
+; CHECK-NEXT:  # %bb.0:
+; CHECK-NEXT:    local.get $push1=, 0
+; CHECK-NEXT:    f32.nearest $push0=, $pop1
+; CHECK-NEXT:    return $pop0
+  %a = call float @llvm.roundeven.f32(float %x)
+  ret float %a
+}
+
 ; This is not "minimum" because a -0.0 input returns +0.0.
 
 define float @fmin32(float %x) {
 ; CHECK-LABEL: fmin32:
 ; CHECK:         .functype fmin32 (f32) -> (f32)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    f32.const $push0=, 0x0p0
 ; CHECK-NEXT:    local.get $push5=, 0

llvm/test/CodeGen/WebAssembly/f64.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s
 
 ; Test that basic 64-bit floating-point operations assemble as expected.
 
 target triple = "wasm32-unknown-unknown"
 
 declare double @llvm.fabs.f64(double)
 declare double @llvm.copysign.f64(double, double)
 declare double @llvm.sqrt.f64(double)
 declare double @llvm.ceil.f64(double)
 declare double @llvm.floor.f64(double)
 declare double @llvm.trunc.f64(double)
 declare double @llvm.nearbyint.f64(double)
 declare double @llvm.rint.f64(double)
+declare double @llvm.roundeven.f64(double)
 declare double @llvm.fma.f64(double, double, double)
 
 define double @fadd64(double %x, double %y) {
 ; CHECK-LABEL: fadd64:
 ; CHECK:         .functype fadd64 (f64, f64) -> (f64)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get $push2=, 0
 ; CHECK-NEXT:    local.get $push1=, 1

 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get $push1=, 0
 ; CHECK-NEXT:    f64.nearest $push0=, $pop1
 ; CHECK-NEXT:    return $pop0
   %a = call double @llvm.rint.f64(double %x)
   ret double %a
 }
 
+define double @nearest64_via_roundeven(double %x) {
+; CHECK-LABEL: nearest64_via_roundeven:
+; CHECK:         .functype nearest64_via_roundeven (f64) -> (f64)
+; CHECK-NEXT:  # %bb.0:
+; CHECK-NEXT:    local.get $push1=, 0
+; CHECK-NEXT:    f64.nearest $push0=, $pop1
+; CHECK-NEXT:    return $pop0
+  %a = call double @llvm.roundeven.f64(double %x)
+  ret double %a
+}
+
 ; This is not "minimum" because a -0.0 input returns +0.0.
 
 define double @fmin64(double %x) {
 ; CHECK-LABEL: fmin64:
 ; CHECK:         .functype fmin64 (f64) -> (f64)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    f64.const $push0=, 0x0p0
 ; CHECK-NEXT:    local.get $push5=, 0

llvm/test/CodeGen/WebAssembly/libcalls.ll

 declare fp128 @llvm.powi.f128.i32(fp128, i32)
 
 declare double @llvm.cos.f64(double)
 declare double @llvm.log10.f64(double)
 declare double @llvm.pow.f64(double, double)
 declare double @llvm.powi.f64.i32(double, i32)
 declare double @llvm.log.f64(double)
 declare double @llvm.exp.f64(double)
-declare double @llvm.roundeven.f64(double)
 declare double @llvm.ldexp.f64.i32(double, i32)
 declare i32 @llvm.lround(double)
 
 define fp128 @fp128libcalls(fp128 %x, fp128 %y, i32 %z) {
   ; compiler-rt call
 ; CHECK-LABEL: fp128libcalls:
 ; CHECK:         .functype fp128libcalls (i32, i64, i64, i64, i64, i32) -> ()
 ; CHECK-NEXT:    .local i32
; CHECK-NEXT:    return
   %c = urem i128 %b, %y
   ret i128 %c
 }
 
 define double @f64libcalls(double %x, double %y, i32 %z) {
 ; CHECK-LABEL: f64libcalls:
 ; CHECK:         .functype f64libcalls (f64, f64, i32) -> (f64)
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get $push13=, 0
-; CHECK-NEXT:    local.get $push10=, 0
-; CHECK-NEXT:    call $push0=, cos, $pop10
+; CHECK-NEXT:    local.get $push12=, 0
+; CHECK-NEXT:    local.get $push9=, 0
+; CHECK-NEXT:    call $push0=, cos, $pop9
 ; CHECK-NEXT:    call $push1=, log10, $pop0
-; CHECK-NEXT:    local.get $push11=, 1
-; CHECK-NEXT:    call $push2=, pow, $pop1, $pop11
-; CHECK-NEXT:    local.get $push12=, 2
-; CHECK-NEXT:    call $push3=, __powidf2, $pop2, $pop12
+; CHECK-NEXT:    local.get $push10=, 1
+; CHECK-NEXT:    call $push2=, pow, $pop1, $pop10
+; CHECK-NEXT:    local.get $push11=, 2
+; CHECK-NEXT:    call $push3=, __powidf2, $pop2, $pop11
 ; CHECK-NEXT:    call $push4=, log, $pop3
 ; CHECK-NEXT:    call $push5=, exp, $pop4
 ; CHECK-NEXT:    call $push6=, cbrt, $pop5
-; CHECK-NEXT:    call $push7=, roundeven, $pop6
-; CHECK-NEXT:    call $push8=, lround, $pop7
-; CHECK-NEXT:    call $push9=, ldexp, $pop13, $pop8
-; CHECK-NEXT:    return $pop9
+; CHECK-NEXT:    call $push7=, lround, $pop6
+; CHECK-NEXT:    call $push8=, ldexp, $pop12, $pop7
+; CHECK-NEXT:    return $pop8
  %a = call double @llvm.cos.f64(double %x)
  %b = call double @llvm.log10.f64(double %a)
  %c = call double @llvm.pow.f64(double %b, double %y)
  %d = call double @llvm.powi.f64.i32(double %c, i32 %z)
  %e = call double @llvm.log.f64(double %d)
  %f = call double @llvm.exp.f64(double %e)
  %g = call fast double @llvm.pow.f64(double %f, double 0x3FD5555555555555)
- %h = call double @llvm.roundeven.f64(double %g)
- %i = call i32 @llvm.lround(double %h)
- %j = call double @llvm.ldexp.f64.i32(double %x, i32 %i);
- ret double %j
+ %h = call i32 @llvm.lround(double %g)
+ %i = call double @llvm.ldexp.f64.i32(double %x, i32 %h);
+ ret double %i
 }
 
 ; fcmp ord and unord (RTLIB::O_F32 / RTLIB::UO_F32 etc) are a special case (see
 ; comment in WebAssemblyRunimeLibcallSignatures.cpp) so check them separately.
 ; no libcalls are needed for f32 and f64
 
 define i1 @unordd(double %x, double %y) {
 ; CHECK-LABEL: unordd:

llvm/test/CodeGen/WebAssembly/simd-intrinsics.ll

 ; CHECK-NEXT: f32x4.nearest $push[[R:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <4 x float> @llvm.nearbyint.v4f32(<4 x float>)
 define <4 x float> @nearest_v4f32(<4 x float> %a) {
   %v = call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %a)
   ret <4 x float> %v
 }
 
+; CHECK-LABEL: nearest_v4f32_via_rint:
+; CHECK-NEXT: .functype nearest_v4f32_via_rint (v128) -> (v128){{$}}
+; CHECK-NEXT: f32x4.nearest $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: return $pop[[R]]{{$}}
+declare <4 x float> @llvm.rint.v4f32(<4 x float>)
+define <4 x float> @nearest_v4f32_via_rint(<4 x float> %a) {
+  %v = call <4 x float> @llvm.rint.v4f32(<4 x float> %a)
+  ret <4 x float> %v
+}
+
+; CHECK-LABEL: nearest_v4f32_via_roundeven:
+; CHECK-NEXT: .functype nearest_v4f32_via_roundeven (v128) -> (v128){{$}}
+; CHECK-NEXT: f32x4.nearest $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: return $pop[[R]]{{$}}
+declare <4 x float> @llvm.roundeven.v4f32(<4 x float>)
+define <4 x float> @nearest_v4f32_via_roundeven(<4 x float> %a) {
+  %v = call <4 x float> @llvm.roundeven.v4f32(<4 x float> %a)
+  ret <4 x float> %v
+}
+
 ; CHECK-LABEL: madd_v4f32:
 ; CHECK-NEXT: .functype madd_v4f32 (v128, v128, v128) -> (v128){{$}}
 ; CHECK-NEXT: f32x4.relaxed_madd $push[[R:[0-9]+]]=, $0, $1, $2{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <4 x float> @llvm.wasm.relaxed.madd.v4f32(<4 x float>, <4 x float>, <4 x float>)
 define <4 x float> @madd_v4f32(<4 x float> %a, <4 x float> %b, <4 x float> %c) {
   %v = call <4 x float> @llvm.wasm.relaxed.madd.v4f32(
     <4 x float> %a, <4 x float> %b, <4 x float> %c

 ; CHECK-NEXT: f64x2.nearest $push[[R:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <2 x double> @llvm.nearbyint.v2f64(<2 x double>)
 define <2 x double> @nearest_v2f64(<2 x double> %a) {
   %v = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %a)
   ret <2 x double> %v
 }
 
+; CHECK-LABEL: nearest_v2f64_via_rint:
+; CHECK-NEXT: .functype nearest_v2f64_via_rint (v128) -> (v128){{$}}
+; CHECK-NEXT: f64x2.nearest $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: return $pop[[R]]{{$}}
+declare <2 x double> @llvm.rint.v2f64(<2 x double>)
+define <2 x double> @nearest_v2f64_via_rint(<2 x double> %a) {
+  %v = call <2 x double> @llvm.rint.v2f64(<2 x double> %a)
+  ret <2 x double> %v
+}
+
+; CHECK-LABEL: nearest_v2f64_via_roundeven:
+; CHECK-NEXT: .functype nearest_v2f64_via_roundeven (v128) -> (v128){{$}}
+; CHECK-NEXT: f64x2.nearest $push[[R:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: return $pop[[R]]{{$}}
+declare <2 x double> @llvm.roundeven.v2f64(<2 x double>)
+define <2 x double> @nearest_v2f64_via_roundeven(<2 x double> %a) {
+  %v = call <2 x double> @llvm.roundeven.v2f64(<2 x double> %a)
+  ret <2 x double> %v
+}
+
 ; CHECK-LABEL: madd_v2f64:
 ; CHECK-NEXT: .functype madd_v2f64 (v128, v128, v128) -> (v128){{$}}
 ; CHECK-NEXT: f64x2.relaxed_madd $push[[R:[0-9]+]]=, $0, $1, $2{{$}}
 ; CHECK-NEXT: return $pop[[R]]{{$}}
 declare <2 x double> @llvm.wasm.relaxed.madd.v2f64(
   <2 x double>, <2 x double>, <2 x double>)
 define <2 x double> @madd_v2f64(<2 x double> %a, <2 x double> %b, <2 x double> %c) {
   %v = call <2 x double> @llvm.wasm.relaxed.madd.v2f64(

llvm/test/CodeGen/WebAssembly/simd-unsupported.ll

 ; CHECK-LABEL: exp2_v4f32:
 ; CHECK: call $push[[L:[0-9]+]]=, exp2f
 declare <4 x float> @llvm.exp2.v4f32(<4 x float>)
 define <4 x float> @exp2_v4f32(<4 x float> %x) {
   %v = call <4 x float> @llvm.exp2.v4f32(<4 x float> %x)
   ret <4 x float> %v
 }
 
-; CHECK-LABEL: rint_v4f32:
-; CHECK: f32.nearest
-declare <4 x float> @llvm.rint.v4f32(<4 x float>)
-define <4 x float> @rint_v4f32(<4 x float> %x) {
-  %v = call <4 x float> @llvm.rint.v4f32(<4 x float> %x)
-  ret <4 x float> %v
-}
-
 ; CHECK-LABEL: round_v4f32:
 ; CHECK: call $push[[L:[0-9]+]]=, roundf
 declare <4 x float> @llvm.round.v4f32(<4 x float>)
 define <4 x float> @round_v4f32(<4 x float> %x) {
   %v = call <4 x float> @llvm.round.v4f32(<4 x float> %x)
   ret <4 x float> %v
 }
 

 ; CHECK-LABEL: exp2_v2f64:
 ; CHECK: call $push[[L:[0-9]+]]=, exp2
 declare <2 x double> @llvm.exp2.v2f64(<2 x double>)
 define <2 x double> @exp2_v2f64(<2 x double> %x) {
   %v = call <2 x double> @llvm.exp2.v2f64(<2 x double> %x)
   ret <2 x double> %v
 }
 
-; CHECK-LABEL: rint_v2f64:
-; CHECK: f64.nearest
-declare <2 x double> @llvm.rint.v2f64(<2 x double>)
-define <2 x double> @rint_v2f64(<2 x double> %x) {
-  %v = call <2 x double> @llvm.rint.v2f64(<2 x double> %x)
-  ret <2 x double> %v
-}
-
 ; CHECK-LABEL: round_v2f64:
 ; CHECK: call $push[[L:[0-9]+]]=, round
 declare <2 x double> @llvm.round.v2f64(<2 x double>)
 define <2 x double> @round_v2f64(<2 x double> %x) {
   %v = call <2 x double> @llvm.round.v2f64(<2 x double> %x)
   ret <2 x double> %v
 }