[GlobalISel] Add G_INTRINSIC_LRINT and translate from llvm.lrint

[arsenm]

This will conflict with D84159.

Why does the IR have rint, lrint, and llrint? libm has all 3, but they seem to just differ by the return integer type? Why isn't there just the one rint intrinsic and clang is responsible for picking the right result type?

[aemerson]

In D84551#2173159, @arsenm wrote:

This will conflict with D84159.

Why does the IR have rint, lrint, and llrint? libm has all 3, but they seem to just differ by the return integer type? Why isn't there just the one rint intrinsic and clang is responsible for picking the right result type?

Conflict in what way?

[arsenm]

In D84551#2173290, @aemerson wrote:

In D84551#2173159, @arsenm wrote:

This will conflict with D84159.

Why does the IR have rint, lrint, and llrint? libm has all 3, but they seem to just differ by the return integer type? Why isn't there just the one rint intrinsic and clang is responsible for picking the right result type?

Conflict in what way?

Touches the same lines

[aemerson]

Ok. I can see there's a different in FP exception behavior for rint but I'm not sure what the difference is between llvm.lrint.i64.f32 and llvm.llrint.f32.

[aemerson]

Update legalizer validation test.

[aemerson]

Ping

[arsenm]

In D84551#2182412, @aemerson wrote:

Ping

These intrinsics were added a lot more recently than I thought by D62017

I think it doesn't really make sense to provide these redundant intrinsics, and math intrinsics are not supposed to provide a 1:1 wrapper around libm. But they're there now, and I would like to eliminate the intrinsic handling delta against SelectionDAG

llvm/include/llvm/Support/TargetOpcodes.def

 HANDLE_TARGET_OPCODE(G_FREEZE)
 
 /// INTRINSIC trunc intrinsic.
 HANDLE_TARGET_OPCODE(G_INTRINSIC_TRUNC)
 
 /// INTRINSIC round intrinsic.
 HANDLE_TARGET_OPCODE(G_INTRINSIC_ROUND)
 
+/// INTRINSIC round to integer intrinsic.
+HANDLE_TARGET_OPCODE(G_INTRINSIC_LRINT)
+
 /// INTRINSIC readcyclecounter
 HANDLE_TARGET_OPCODE(G_READCYCLECOUNTER)
 
 /// Generic load (including anyext load)
 HANDLE_TARGET_OPCODE(G_LOAD)
 
 /// Generic signext load
 HANDLE_TARGET_OPCODE(G_SEXTLOAD)

llvm/include/llvm/Target/GenericOpcodes.td

 }
 
 def G_INTRINSIC_ROUND : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1);
   let hasSideEffects = 0;
 }
 
+def G_INTRINSIC_LRINT : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins type1:$src);
+  let hasSideEffects = 0;
+}
+
 def G_READCYCLECOUNTER : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins);
   let hasSideEffects = 1;
 }
 
 //------------------------------------------------------------------------------
 // Memory ops

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

switch (ID) {
     case Intrinsic::sqrt:
       return TargetOpcode::G_FSQRT;
     case Intrinsic::trunc:
       return TargetOpcode::G_INTRINSIC_TRUNC;
     case Intrinsic::readcyclecounter:
       return TargetOpcode::G_READCYCLECOUNTER;
     case Intrinsic::ptrmask:
       return TargetOpcode::G_PTRMASK;
+    case Intrinsic::lrint:
+      return TargetOpcode::G_INTRINSIC_LRINT;
   }
   return Intrinsic::not_intrinsic;
 }
 
 bool IRTranslator::translateSimpleIntrinsic(const CallInst &CI,
                                             Intrinsic::ID ID,
                                             MachineIRBuilder &MIRBuilder) {
 

llvm/test/CodeGen/AArch64/GlobalISel/arm64-irtranslator.ll

 ; CHECK-LABEL: name: test_intrinsic_round
 ; CHECK: [[A:%[0-9]+]]:_(s32) = COPY $s0
 ; CHECK: [[RES:%[0-9]+]]:_(s32) = G_INTRINSIC_ROUND [[A]]
 ; CHECK: $s0 = COPY [[RES]]
   %res = call float @llvm.round.f32(float %a)
   ret float %res
 }
 
+declare i32 @llvm.lrint.i32.f32(float)
+define i32 @test_intrinsic_lrint(float %a) {
+; CHECK-LABEL: name: test_intrinsic_lrint
+; CHECK: [[A:%[0-9]+]]:_(s32) = COPY $s0
+; CHECK: [[RES:%[0-9]+]]:_(s32) = G_INTRINSIC_LRINT [[A]]
+; CHECK: $w0 = COPY [[RES]]
+  %res = call i32 @llvm.lrint.i32.f32(float %a)
+  ret i32 %res
+}
+
 declare i32 @llvm.ctlz.i32(i32, i1)
 define i32 @test_ctlz_intrinsic_zero_not_undef(i32 %a) {
 ; CHECK-LABEL: name: test_ctlz_intrinsic_zero_not_undef
 ; CHECK: [[A:%[0-9]+]]:_(s32) = COPY $w0
 ; CHECK: [[RES:%[0-9]+]]:_(s32) = G_CTLZ [[A]]
 ; CHECK: $w0 = COPY [[RES]]
   %res = call i32 @llvm.ctlz.i32(i32 %a, i1 0)
   ret i32 %res