[CodeGen] Add lround/llround builtins

[zatrazz]

Summary

This patch add the ISD::LROUND and ISD::LLROUND along with new
intrinsics. The changes are straightforward as for other
floating-point rounding functions, with just some adjustments
required to handle the return value being an interger.

The idea is to optimize lround/llround generation for AArch64
in a subsequent patch. Current semantic is just route it to libm
symbol.

[craig.topper]

llvm/docs/LangRef.rst

12354

How can this support vector if the result type is hardcoded to i32/i64?

[craig.topper]

llvm/lib/CodeGen/TargetLoweringBase.cpp

717

I wonder if it wouldn't make more sense to index the operation action table by the FP type rather than the result type.

[zatrazz]

Updated patch based on previous comments. The changes from the previous version are:

• Remove support vector types from documentation of the new instrinsics.
• Index the new operations based on input argument rather than return ones.
• Added tests for i32 variant (lround for long int being i32).
• Added support and tests for soft-float lowering.

[zatrazz]

In fact, it turned out that indexing the new lround/llround based on
input argument didn't really make it correctly handled as an expanded
operation. I will dig into exactly why backend is not selecting correctly
based on input argument, so I change it back to previous indexing by
return type.

I have clean up the testscase to remove duplicated entries and add a
x86_64 one so the code path to lower to libcalls will still be stressed
(since the idea for AArch64 is optimize to specific instructions).

[craig.topper]

To use the FP type you need to add the new ISD opcodes to the switch in SelectionDAGLegalize::LegalizeOp that assigns the Action variable. You'll need to call TLI.getOperationAction on the first operand type.

[zatrazz]

Updated patch based on the previous comment. The main change are:

• Add the new ISD on SelectionDAGLegalize::LegalizeOp.
• Index both lround/llround by returned type.

[craig.topper]

llvm/docs/LangRef.rst

12354

Add 'type' after 'floating-point'.

12395

floating-point type.

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

2148

Drop the isSigned argument like ExpandFPLibCall

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

775 ↗

(On Diff #198318)

Why is only LROUND handled here? Shouldn't the floating point handling need to be the same regardless of the integer type?

[craig.topper]

llvm/lib/CodeGen/TargetLoweringBase.cpp

701

Instead of adding f80 here which only X86 needs, just add the new nodes in the same spot as FLOG, FLOG2, FLOG10, etc. in X86ISelLowering.cpp

[craig.topper]

Can you test lround.i32 with -mtriple=i686-unknown with and without -mattr=sse2.

Use utils/update_llc_test_checks.py to generate the checks for at least X86. Try it on the other targets too if it works for them.

[zatrazz]

In D61390#1492891, @craig.topper wrote:

Can you test lround.i32 with -mtriple=i686-unknown with and without -mattr=sse2.

Use utils/update_llc_test_checks.py to generate the checks for at least X86. Try it on the other targets too if it works for them.

I have added a lround.i32 for i686 as you asked using utils/update_llc_test_checks.py. I will update the patch.

llvm/docs/LangRef.rst

12354

Ack.

12395

Ack.

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

2148

Ack.

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

775 ↗

(On Diff #198318)

It should and it haven't added because the test coverage didn't actually hit the requirement. With the updated patch that check for 64-bit soft-float (Mips64) I have added the LLROUND handling as well.

llvm/lib/CodeGen/TargetLoweringBase.cpp

701

Ack.

[zatrazz]

Updated patch based on previous comments. The changes are:

• Fix documentation missing words.
• Removed isSigned from ExpandFPLibCall.
• Added LLROUND along with a proper tests (for mips64) for soft-float.
• Moved TargetLoweringBase::initActions action for f80 on x86 code.
• Added lround.i32 for i686 tests using utils/update_llc_test_checks.py.

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

2164

Doesn't ExpandFPLibCall pass false for the last argument? We should probably do the same here.

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

2491 ↗

(On Diff #198532)

Mark that bool flag as irrelevant like ExpandIntRes_FP_TO_UINT and ExpandIntRes_FP_TO_SINT?

[zatrazz]

Updated patch based on previous review.

[craig.topper]

LGTM

[craig.topper]

Should we have a PowerPC test for ppcf128?

[zatrazz]

In D61390#1495541, @craig.topper wrote:

Should we have a PowerPC test for ppcf128?

I will update the patch to add one.

[zatrazz]

Updated patch based on the previous comment. The main change is the IBM long double tests which also required both SoftenFloatOp_LROUND and SoftenFloatOp_LLROUND implementation to handle the type correctly.

[zatrazz]

Ping.

[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.lround.*``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+This is an overloaded intrinsic. You can use ``llvm.lround`` on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.
+
+::
+
+      declare i32 @llvm.lround.i32.f32(float %Val)
+      declare i32 @llvm.lround.i32.f64(double %Val)
+      declare i32 @llvm.lround.i32.f80(float %Val)
+      declare i32 @llvm.lround.i32.f128(double %Val)
+      declare i32 @llvm.lround.i32.ppcf128(double %Val)
+
+      declare i64 @llvm.lround.i64.f32(float %Val)
+      declare i64 @llvm.lround.i64.f64(double %Val)
+      declare i64 @llvm.lround.i64.f80(float %Val)
+      declare i64 @llvm.lround.i64.f128(double %Val)
+      declare i64 @llvm.lround.i64.ppcf128(double %Val)
+
+Overview:
+"""""""""
+
+The '``llvm.lround.*``' intrinsics returns the operand rounded to the
+nearest integer.
+
+Arguments:
+""""""""""
+
+The argument is a floating-point number and return is i32 for
+``llvm.lround.i32`` and i64 for ``llvm.lround.i64``.
+
+Semantics:
+""""""""""
+
+This function returns the same values as the libm ``lround``
+functions would, but without setting errno.
+
+'``llvm.llround.*``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+This is an overloaded intrinsic. You can use ``llvm.llround`` on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.
+
+::
+
+      declare i64 @llvm.lround.f32(float %Val)
+      declare i64 @llvm.lround.f64(double %Val)
+      declare i64 @llvm.lround.f80(float %Val)
+      declare i64 @llvm.lround.f128(double %Val)
+      declare i64 @llvm.lround.ppcf128(double %Val)
+
+Overview:
+"""""""""
+
+The '``llvm.llround.*``' intrinsics returns the operand rounded to the
+nearest integer.
+
+Arguments:
+""""""""""
+
+The argument is a floating-point number and return is i64.
+
+Semantics:
+""""""""""
+
+This function returns the same values as the libm ``llround``
+functions would, but without setting errno.
+
 Bit Manipulation Intrinsics
 ---------------------------
 
 LLVM provides intrinsics for a few important bit manipulation
 operations. These allow efficient code generation for some algorithms.
 
 '``llvm.bitreverse.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

llvm/include/llvm/CodeGen/ISDOpcodes.h

enum NodeType {
     FP16_TO_FP, FP_TO_FP16,
 
     /// Perform various unary floating-point operations inspired by libm. For
     /// FPOWI, the result is undefined if if the integer operand doesn't fit
     /// into 32 bits.
     FNEG, FABS, FSQRT, FCBRT, FSIN, FCOS, FPOWI, FPOW,
     FLOG, FLOG2, FLOG10, FEXP, FEXP2,
     FCEIL, FTRUNC, FRINT, FNEARBYINT, FROUND, FFLOOR,
+    LROUND, LLROUND,
+
     /// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
     /// values.
     //
     /// In the case where a single input is a NaN (either signaling or quiet),
     /// the non-NaN input is returned.
     ///
     /// The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
     FMINNUM, FMAXNUM,

llvm/include/llvm/IR/Intrinsics.td

let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
   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_canonicalize : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
                                    [IntrNoMem]>;
+
+  def int_lround_i32 : Intrinsic<[llvm_i32_ty], [llvm_anyfloat_ty]>;
+  def int_lround_i64 : Intrinsic<[llvm_i64_ty], [llvm_anyfloat_ty]>;
+  def int_llround    : Intrinsic<[llvm_i64_ty], [llvm_anyfloat_ty]>;
 }
 
 def int_minnum : Intrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],
   [IntrNoMem, IntrSpeculatable, Commutative]
 >;
 def int_maxnum : Intrinsic<[llvm_anyfloat_ty],
   [LLVMMatchType<0>, LLVMMatchType<0>],

llvm/include/llvm/IR/RuntimeLibcalls.def

 HANDLE_LIBCALL(FMIN_F80, "fminl")
 HANDLE_LIBCALL(FMIN_F128, "fminl")
 HANDLE_LIBCALL(FMIN_PPCF128, "fminl")
 HANDLE_LIBCALL(FMAX_F32, "fmaxf")
 HANDLE_LIBCALL(FMAX_F64, "fmax")
 HANDLE_LIBCALL(FMAX_F80, "fmaxl")
 HANDLE_LIBCALL(FMAX_F128, "fmaxl")
 HANDLE_LIBCALL(FMAX_PPCF128, "fmaxl")
+HANDLE_LIBCALL(LROUND_F32, "lroundf")
+HANDLE_LIBCALL(LROUND_F64, "lround")
+HANDLE_LIBCALL(LROUND_F80, "lroundl")
+HANDLE_LIBCALL(LROUND_F128, "lroundl")
+HANDLE_LIBCALL(LROUND_PPCF128, "lroundl")
+HANDLE_LIBCALL(LLROUND_F32, "llroundf")
+HANDLE_LIBCALL(LLROUND_F64, "llround")
+HANDLE_LIBCALL(LLROUND_F80, "llroundl")
+HANDLE_LIBCALL(LLROUND_F128, "llroundl")
+HANDLE_LIBCALL(LLROUND_PPCF128, "llroundl")
 
 // Conversion
 HANDLE_LIBCALL(FPEXT_F32_PPCF128, "__gcc_stoq")
 HANDLE_LIBCALL(FPEXT_F64_PPCF128, "__gcc_dtoq")
 HANDLE_LIBCALL(FPEXT_F80_F128, "__extendxftf2")
 HANDLE_LIBCALL(FPEXT_F64_F128, "__extenddftf2")
 HANDLE_LIBCALL(FPEXT_F32_F128, "__extendsftf2")
 HANDLE_LIBCALL(FPEXT_F32_F64, "__extendsfdf2")

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

SDValue ExpandFPLibCall(SDNode *Node, RTLIB::Libcall Call_F32,
                           RTLIB::Libcall Call_F128,
                           RTLIB::Libcall Call_PPCF128);
   SDValue ExpandIntLibCall(SDNode *Node, bool isSigned,
                            RTLIB::Libcall Call_I8,
                            RTLIB::Libcall Call_I16,
                            RTLIB::Libcall Call_I32,
                            RTLIB::Libcall Call_I64,
                            RTLIB::Libcall Call_I128);
+  SDValue ExpandArgFPLibCall(SDNode *Node, bool isSigned,
+                             RTLIB::Libcall Call_F32, RTLIB::Libcall Call_F64,
+                             RTLIB::Libcall Call_F80, RTLIB::Libcall Call_F128,
+                             RTLIB::Libcall Call_PPCF128);
   void ExpandDivRemLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
   void ExpandSinCosLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
 
   SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
                            const SDLoc &dl);
   SDValue ExpandBUILD_VECTOR(SDNode *Node);
   SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node);
   void ExpandDYNAMIC_STACKALLOC(SDNode *Node,
SDValue SelectionDAGLegalize::ExpandIntLibCall(SDNode* Node, bool isSigned,
   case MVT::i16:  LC = Call_I16; break;
   case MVT::i32:  LC = Call_I32; break;
   case MVT::i64:  LC = Call_I64; break;
   case MVT::i128: LC = Call_I128; break;
   }
   return ExpandLibCall(LC, Node, isSigned);
 }
 
+/// Expand the node to a libcall based on first argument type (for instance
+/// lround and its variant).
+SDValue SelectionDAGLegalize::ExpandArgFPLibCall(SDNode* Node, bool isSigned,
+                                                 RTLIB::Libcall Call_F32,
+                                                 RTLIB::Libcall Call_F64,
+                                                 RTLIB::Libcall Call_F80,
+                                                 RTLIB::Libcall Call_F128,
+                                                 RTLIB::Libcall Call_PPCF128) {
+  RTLIB::Libcall LC;
+  switch (Node->getOperand(0).getValueType().getSimpleVT().SimpleTy) {
+  default: llvm_unreachable("Unexpected request for libcall!");
+  case MVT::f32:     LC = Call_F32; break;
+  case MVT::f64:     LC = Call_F64; break;
+  case MVT::f80:     LC = Call_F80; break;
+  case MVT::f128:    LC = Call_F128; break;
+  case MVT::ppcf128: LC = Call_PPCF128; break;
+  }
+
+  return ExpandLibCall(LC, Node, isSigned);
+}
+
 /// Issue libcalls to __{u}divmod to compute div / rem pairs.
 void
 SelectionDAGLegalize::ExpandDivRemLibCall(SDNode *Node,
                                           SmallVectorImpl<SDValue> &Results) {
   unsigned Opcode = Node->getOpcode();
   bool isSigned = Opcode == ISD::SDIVREM;
 
   RTLIB::Libcall LC;
bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
   case ISD::FP_TO_SINT:
     if (TLI.expandFP_TO_SINT(Node, Tmp1, DAG))
       Results.push_back(Tmp1);
     break;
   case ISD::FP_TO_UINT:
     if (TLI.expandFP_TO_UINT(Node, Tmp1, DAG))
       Results.push_back(Tmp1);
     break;
+  case ISD::LROUND:
+    Results.push_back(ExpandArgFPLibCall(Node, true, RTLIB::LROUND_F32,
+                                         RTLIB::LROUND_F64, RTLIB::LROUND_F80,
+                                         RTLIB::LROUND_F128,
+                                         RTLIB::LROUND_PPCF128));
+    break;
+  case ISD::LLROUND:
+    Results.push_back(ExpandArgFPLibCall(Node, true, RTLIB::LLROUND_F32,
+                                         RTLIB::LLROUND_F64, RTLIB::LLROUND_F80,
+                                         RTLIB::LLROUND_F128,
+                                         RTLIB::LLROUND_PPCF128));
+    break;
   case ISD::VAARG:
     Results.push_back(DAG.expandVAArg(Node));
     Results.push_back(Results[0].getValue(1));
     break;
   case ISD::VACOPY:
     Results.push_back(DAG.expandVACopy(Node));
     break;
   case ISD::EXTRACT_VECTOR_ELT:

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::canonicalize: {
     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::canonicalize: Opcode = ISD::FCANONICALIZE; break;
+    case Intrinsic::lround_i32: Opcode = ISD::LROUND;    break;
+    case Intrinsic::lround_i64: Opcode = ISD::LROUND;    break;
+    case Intrinsic::llround:   Opcode = ISD::LLROUND;    break;
     }
 
     setValue(&I, DAG.getNode(Opcode, sdl,
                              getValue(I.getArgOperand(0)).getValueType(),
                              getValue(I.getArgOperand(0))));
     return nullptr;
   }
+  case Intrinsic::lround_i32:
+  case Intrinsic::lround_i64:
+  case Intrinsic::llround: {
+    unsigned Opcode;
+    MVT RetVT;
+    switch (Intrinsic) {
+    default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
+    case Intrinsic::lround_i32: Opcode = ISD::LROUND;  RetVT = MVT::i32; break;
+    case Intrinsic::lround_i64: Opcode = ISD::LROUND;  RetVT = MVT::i64; break;
+    case Intrinsic::llround:    Opcode = ISD::LLROUND; RetVT = MVT::i64; break;
+    }
+
+    setValue(&I, DAG.getNode(Opcode, sdl, RetVT,
+                             getValue(I.getArgOperand(0))));
+    return nullptr;
+  }
   case Intrinsic::minnum: {
     auto VT = getValue(I.getArgOperand(0)).getValueType();
     unsigned Opc =
         I.hasNoNaNs() && TLI.isOperationLegalOrCustom(ISD::FMINIMUM, VT)
             ? ISD::FMINIMUM
             : ISD::FMINNUM;
     setValue(&I, DAG.getNode(Opc, sdl, VT,
                              getValue(I.getArgOperand(0)),

llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

#endif
   case ISD::SINT_TO_FP:                 return "sint_to_fp";
   case ISD::UINT_TO_FP:                 return "uint_to_fp";
   case ISD::FP_TO_SINT:                 return "fp_to_sint";
   case ISD::FP_TO_UINT:                 return "fp_to_uint";
   case ISD::BITCAST:                    return "bitcast";
   case ISD::ADDRSPACECAST:              return "addrspacecast";
   case ISD::FP16_TO_FP:                 return "fp16_to_fp";
   case ISD::FP_TO_FP16:                 return "fp_to_fp16";
+  case ISD::LROUND:                     return "lround";
+  case ISD::LLROUND:                    return "llround";
 
     // Control flow instructions
   case ISD::BR:                         return "br";
   case ISD::BRIND:                      return "brind";
   case ISD::BR_JT:                      return "br_jt";
   case ISD::BRCOND:                     return "brcond";
   case ISD::BR_CC:                      return "br_cc";
   case ISD::CALLSEQ_START:              return "callseq_start";

llvm/lib/CodeGen/TargetLoweringBase.cpp

void TargetLoweringBase::initActions() {
   // to optimize expansions for certain constants.
   setOperationAction(ISD::ConstantFP, MVT::f16, Expand);
   setOperationAction(ISD::ConstantFP, MVT::f32, Expand);
   setOperationAction(ISD::ConstantFP, MVT::f64, Expand);
   setOperationAction(ISD::ConstantFP, MVT::f80, Expand);
   setOperationAction(ISD::ConstantFP, MVT::f128, Expand);
 
   // These library functions default to expand.
   for (MVT VT : {MVT::f32, MVT::f64, MVT::f128}) {
     setOperationAction(ISD::FCBRT,      VT, Expand);
     setOperationAction(ISD::FLOG ,      VT, Expand);
     setOperationAction(ISD::FLOG2,      VT, Expand);
     setOperationAction(ISD::FLOG10,     VT, Expand);
     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);
   }
 
+  // More library functions default to expand.
+  setOperationAction(ISD::LROUND,  MVT::i32, Expand);
+  setOperationAction(ISD::LROUND,  MVT::i64, Expand);
+  setOperationAction(ISD::LLROUND, MVT::i64, Expand);
+
   // Default ISD::TRAP to expand (which turns it into abort).
   setOperationAction(ISD::TRAP, MVT::Other, Expand);
 
   // On most systems, DEBUGTRAP and TRAP have no difference. The "Expand"
   // here is to inform DAG Legalizer to replace DEBUGTRAP with TRAP.
   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Expand);
 }
 

llvm/test/CodeGen/AArch64/llround-conv.ll

+; RUN: llc < %s -mtriple=aarch64 -mattr=+neon | FileCheck %s
+
+; CHECK-LABEL: testmsws:
+; CHECK:       bl      llroundf
+define i32 @testmsws(float %x) {
+entry:
+  %call = tail call i64 @llroundf(float %x) #2
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmsxs:
+; CHECK:       b       llroundf
+define i64 @testmsxs(float %x) {
+entry:
+  %call = tail call i64 @llroundf(float %x) #2
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmswd:
+; CHECK:       bl      llround
+define i32 @testmswd(double %x) {
+entry:
+  %call = tail call i64 @llround(double %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmsxd:
+; CHECK:       b       llround
+define i64 @testmsxd(double %x) {
+entry:
+  %call = tail call i64 @llround(double %x)
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmuws:
+; CHECK:       bl      llroundf
+define i32 @testmuws(float %x) {
+entry:
+  %call = tail call i64 @llroundf(float %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmuxs:
+; CHECK:       b       llroundf
+define i64 @testmuxs(float %x) {
+entry:
+  %call = tail call i64 @llroundf(float %x)
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmuwd:
+; CHECK:       bl      llround
+define i32 @testmuwd(double %x) {
+entry:
+  %call = tail call i64 @llround(double %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmuxd:
+; CHECK:       b       llround
+define i64 @testmuxd(double %x) {
+entry:
+  %call = tail call i64 @llround(double %x)
+  ret i64 %call
+}
+
+declare i64 @llroundf(float) nounwind
+declare i64 @llround(double) nounwind

llvm/test/CodeGen/AArch64/lround-conv.ll

+; RUN: llc < %s -mtriple=aarch64 -mattr=+neon | FileCheck %s
+
+; CHECK-LABEL: testmsws:
+; CHECK:       bl      lroundf
+define i32 @testmsws(float %x) {
+entry:
+  %call = tail call i64 @lroundf(float %x) #2
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmsxs:
+; CHECK:       b       lroundf
+define i64 @testmsxs(float %x) {
+entry:
+  %call = tail call i64 @lroundf(float %x) #2
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmswd:
+; CHECK:       bl      lround
+define i32 @testmswd(double %x) {
+entry:
+  %call = tail call i64 @lround(double %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmsxd:
+; CHECK:       b       lround
+define i64 @testmsxd(double %x) {
+entry:
+  %call = tail call i64 @lround(double %x)
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmuws:
+; CHECK:       bl      lroundf
+define i32 @testmuws(float %x) {
+entry:
+  %call = tail call i64 @lroundf(float %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmuxs:
+; CHECK:       b       lroundf
+define i64 @testmuxs(float %x) {
+entry:
+  %call = tail call i64 @lroundf(float %x)
+  ret i64 %call
+}
+
+; CHECK-LABEL: testmuwd:
+; CHECK:       bl      lround
+define i32 @testmuwd(double %x) {
+entry:
+  %call = tail call i64 @lround(double %x)
+  %conv = trunc i64 %call to i32
+  ret i32 %conv
+}
+
+; CHECK-LABEL: testmuxd:
+; CHECK:       b       lround
+define i64 @testmuxd(double %x) {
+entry:
+  %call = tail call i64 @lround(double %x)
+  ret i64 %call
+}
+
+declare i64 @lroundf(float) nounwind
+declare i64 @lround(double) nounwind