[GlobalISel] Legalize more G_FP(EXT|TRUNC) libcalls.

[kschwarz]

Summary

This adds a new helper function for retrieving the floating point type corresponding to the specified bit-width.

[arsenm]

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

118

It might be better to pass the LLT instead of just the size in case new exotic LLTs are introduced for weird FP types in the future

129

Return null and report legalization failure?

[kschwarz]

Address review comments

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

118

Makes sense

129

Definitely better than crashing. It requires all call sites to handle the nullptr though.

[arsenm]

Testcase?

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

740

demorgan this

[kschwarz]

Should this be a unit test then, since there is no in-tree target currently requiring a libcall for this?

[arsenm]

In D73948#1859385, @kschwarz wrote:

Should this be a unit test then, since there is no in-tree target currently requiring a libcall for this?

That would work

[kschwarz]

Unit tests added for the previously unsupported extensions & truncations.
Tightened the size check for simple libcalls to avoid crash on unsupported libcalls.

[arsenm]

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

725

You can move this under the getFloatTypeForLLT check since it's somewhat redundant

llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

1205–1206

EXPECT_EQ(Legalized, ...)

1247–1251

Ditto

[kschwarz]

Move check
Change EXPECT_TRUE -> EXPECT_EQ

[kschwarz]

@arsenm, thanks for the review! Would you mind committing this for me?

[arsenm]

76986bdc4633b0a8bdee1ad4f2e279f17e7f747a

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

if (Ty0.isVector() && Ty1.isVector()) {
 
     int Mul = Ty0.getNumElements() * Ty1.getNumElements();
     return LLT::vector(Mul / GCDElts, Ty0.getElementType());
   }
 
   llvm_unreachable("not yet handled");
 }
 
+static Type *getFloatTypeForLLT(LLVMContext &Ctx, LLT Ty) {
+
+  if (!Ty.isScalar())
+    return nullptr;
+
+  switch (Ty.getSizeInBits()) {
+  case 16:
+    return Type::getHalfTy(Ctx);
+  case 32:
+    return Type::getFloatTy(Ctx);
+  case 64:
+    return Type::getDoubleTy(Ctx);
+  case 128:
+    return Type::getFP128Ty(Ctx);
+  default:
+    return nullptr;
+  }
+}
+
 LegalizerHelper::LegalizerHelper(MachineFunction &MF,
                                  GISelChangeObserver &Observer,
                                  MachineIRBuilder &Builder)
     : MIRBuilder(Builder), MRI(MF.getRegInfo()),
       LI(*MF.getSubtarget().getLegalizerInfo()), Observer(Observer) {
   MIRBuilder.setMF(MF);
   MIRBuilder.setChangeObserver(Observer);
 }
LegalizerHelper::libcall(MachineInstr &MI) {
   case TargetOpcode::G_FSIN:
   case TargetOpcode::G_FLOG10:
   case TargetOpcode::G_FLOG:
   case TargetOpcode::G_FLOG2:
   case TargetOpcode::G_FEXP:
   case TargetOpcode::G_FEXP2:
   case TargetOpcode::G_FCEIL:
   case TargetOpcode::G_FFLOOR: {
-    if (Size > 64) {
-      LLVM_DEBUG(dbgs() << "Size " << Size << " too large to legalize.\n");
+    Type *HLTy = getFloatTypeForLLT(Ctx, LLTy);
+    if (!HLTy || (Size != 32 && Size != 64)) {
+      LLVM_DEBUG(dbgs() << "No libcall available for size " << Size << ".\n");
       return UnableToLegalize;
     }
-    Type *HLTy = Size == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx);
     auto Status = simpleLibcall(MI, MIRBuilder, Size, HLTy);
     if (Status != Legalized)
       return Status;
     break;
   }
-  case TargetOpcode::G_FPEXT: {
-    // FIXME: Support other floating point types (half, fp128 etc)
-    unsigned FromSize = MRI.getType(MI.getOperand(1).getReg()).getSizeInBits();
-    unsigned ToSize = MRI.getType(MI.getOperand(0).getReg()).getSizeInBits();
-    if (ToSize != 64 || FromSize != 32)
-      return UnableToLegalize;
-    LegalizeResult Status = conversionLibcall(
-        MI, MIRBuilder, Type::getDoubleTy(Ctx), Type::getFloatTy(Ctx));
-    if (Status != Legalized)
-      return Status;
-    break;
-  }
+  case TargetOpcode::G_FPEXT:
   case TargetOpcode::G_FPTRUNC: {
-    // FIXME: Support other floating point types (half, fp128 etc)
-    unsigned FromSize = MRI.getType(MI.getOperand(1).getReg()).getSizeInBits();
-    unsigned ToSize = MRI.getType(MI.getOperand(0).getReg()).getSizeInBits();
-    if (ToSize != 32 || FromSize != 64)
+    Type *FromTy = getFloatTypeForLLT(Ctx,  MRI.getType(MI.getOperand(1).getReg()));
+    Type *ToTy = getFloatTypeForLLT(Ctx, MRI.getType(MI.getOperand(0).getReg()));
+    if (!FromTy || !ToTy)
       return UnableToLegalize;
-    LegalizeResult Status = conversionLibcall(
-        MI, MIRBuilder, Type::getFloatTy(Ctx), Type::getDoubleTy(Ctx));
+    LegalizeResult Status = conversionLibcall(MI, MIRBuilder, ToTy, FromTy );
     if (Status != Legalized)
       return Status;
     break;
   }
   case TargetOpcode::G_FPTOSI:
   case TargetOpcode::G_FPTOUI: {
     // FIXME: Support other types
     unsigned FromSize = MRI.getType(MI.getOperand(1).getReg()).getSizeInBits();
case TargetOpcode::G_UMULO: {
     return Legalized;
   }
   case TargetOpcode::G_FNEG: {
     // TODO: Handle vector types once we are able to
     // represent them.
     if (Ty.isVector())
       return UnableToLegalize;
     Register Res = MI.getOperand(0).getReg();
-    Type *ZeroTy;
     LLVMContext &Ctx = MIRBuilder.getMF().getFunction().getContext();
-    switch (Ty.getSizeInBits()) {
-    case 16:
-      ZeroTy = Type::getHalfTy(Ctx);
-      break;
-    case 32:
-      ZeroTy = Type::getFloatTy(Ctx);
-      break;
-    case 64:
-      ZeroTy = Type::getDoubleTy(Ctx);
-      break;
-    case 128:
-      ZeroTy = Type::getFP128Ty(Ctx);
-      break;
-    default:
-      llvm_unreachable("unexpected floating-point type");
-    }
+    Type *ZeroTy = getFloatTypeForLLT(Ctx, Ty);
+    if (!ZeroTy)
+      return UnableToLegalize;
     ConstantFP &ZeroForNegation =
         *cast<ConstantFP>(ConstantFP::getZeroValueForNegation(ZeroTy));
     auto Zero = MIRBuilder.buildFConstant(Ty, ZeroForNegation);
     Register SubByReg = MI.getOperand(1).getReg();
     Register ZeroReg = Zero.getReg(0);
     MIRBuilder.buildFSub(Res, ZeroReg, SubByReg, MI.getFlags());
     MI.eraseFromParent();
     return Legalized;

llvm/unittests/CodeGen/GlobalISel/GISelMITest.h

Name##Info(const TargetSubtargetInfo &ST) {                                \
       const LLT s8 = LLT::scalar(8);                                           \
       (void)s8;                                                                \
       const LLT s16 = LLT::scalar(16);                                         \
       (void)s16;                                                               \
       const LLT s32 = LLT::scalar(32);                                         \
       (void)s32;                                                               \
       const LLT s64 = LLT::scalar(64);                                         \
       (void)s64;                                                               \
+      const LLT s128 = LLT::scalar(128);                                       \
+      (void)s128;                                                              \
       do                                                                       \
         SettingUpActionsBlock while (0);                                       \
       computeTables();                                                         \
       verify(*ST.getInstrInfo());                                              \
     }                                                                          \
   };
 
 static inline bool CheckMachineFunction(const MachineFunction &MF,

llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

TEST_F(GISelMITest, LowerSEXTINREG) {
   CHECK: [[CST:%[0-9]+]]:_(s32) = G_CONSTANT i32 24
   CHECK: [[T2:%[0-9]+]]:_(s32) = G_SHL [[T1]]:_, [[CST]]:_
   CHECK: [[T3:%[0-9]+]]:_(s32) = G_ASHR [[T2]]:_, [[CST]]:_
   )";
 
   // Check
   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 }
+
+TEST_F(GISelMITest, LibcallFPExt) {
+  setUp();
+  if (!TM)
+    return;
+
+  // Declare your legalization info
+  DefineLegalizerInfo(A, {
+    getActionDefinitionsBuilder(G_FPEXT).libcallFor({{s32, s16}, {s128, s64}});
+  });
+
+  LLT S16{LLT::scalar(16)};
+  LLT S32{LLT::scalar(32)};
+  LLT S128{LLT::scalar(128)};
+  auto MIBTrunc = B.buildTrunc(S16, Copies[0]);
+  auto MIBFPExt1 =
+      B.buildInstr(TargetOpcode::G_FPEXT, {S32}, {MIBTrunc});
+
+  auto MIBFPExt2 =
+      B.buildInstr(TargetOpcode::G_FPEXT, {S128}, {Copies[1]});
+  AInfo Info(MF->getSubtarget());
+  DummyGISelObserver Observer;
+  LegalizerHelper Helper(*MF, Info, Observer, B);
+  EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
+              Helper.libcall(*MIBFPExt1));
+
+  EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
+              Helper.libcall(*MIBFPExt2));
+  auto CheckStr = R"(
+  CHECK: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC
+  CHECK: $h0 = COPY [[TRUNC]]
+  CHECK: BL &__gnu_h2f_ieee
+  CHECK: $d0 = COPY
+  CHECK: BL &__extenddftf2
+  )";
+
+  // Check
+  EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
+}
+
+TEST_F(GISelMITest, LibcallFPTrunc) {
+  setUp();
+  if (!TM)
+    return;
+
+  // Declare your legalization info
+  DefineLegalizerInfo(A, {
+    getActionDefinitionsBuilder(G_FPTRUNC).libcallFor({{s16, s32}, {s64, s128}});
+  });
+
+  LLT S16{LLT::scalar(16)};
+  LLT S32{LLT::scalar(32)};
+  LLT S64{LLT::scalar(64)};
+  LLT S128{LLT::scalar(128)};
+  auto MIBTrunc = B.buildTrunc(S32, Copies[0]);
+  auto MIBFPTrunc1 =
+      B.buildInstr(TargetOpcode::G_FPTRUNC, {S16}, {MIBTrunc});
+
+  auto MIBMerge = B.buildMerge(S128, {Copies[1], Copies[2]});
+
+  auto MIBFPTrunc2 =
+      B.buildInstr(TargetOpcode::G_FPTRUNC, {S64}, {MIBMerge});
+  AInfo Info(MF->getSubtarget());
+  DummyGISelObserver Observer;
+  LegalizerHelper Helper(*MF, Info, Observer, B);
+  EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
+            Helper.libcall(*MIBFPTrunc1));
+
+  EXPECT_EQ(LegalizerHelper::LegalizeResult::Legalized,
+            Helper.libcall(*MIBFPTrunc2));
+  auto CheckStr = R"(
+  CHECK: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC
+  CHECK: $s0 = COPY [[TRUNC]]
+  CHECK: BL &__gnu_f2h_ieee
+  CHECK: $q0 = COPY
+  CHECK: BL &__trunctfdf2
+  )";
+
+  // Check
+  EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
+}
+
+TEST_F(GISelMITest, LibcallSimple) {
+  setUp();
+  if (!TM)
+    return;
+
+  // Declare your legalization info
+  DefineLegalizerInfo(A, {
+    getActionDefinitionsBuilder(G_FADD).libcallFor({s16});
+  });
+
+  LLT S16{LLT::scalar(16)};
+  auto MIBTrunc = B.buildTrunc(S16, Copies[0]);
+  auto MIBFADD =
+      B.buildInstr(TargetOpcode::G_FADD, {S16}, {MIBTrunc, MIBTrunc});
+
+  AInfo Info(MF->getSubtarget());
+  DummyGISelObserver Observer;
+  LegalizerHelper Helper(*MF, Info, Observer, B);
+  // Make sure we do not crash anymore
+  EXPECT_EQ(LegalizerHelper::LegalizeResult::UnableToLegalize,
+            Helper.libcall(*MIBFADD));
+}
 } // namespace