Add CTTZ libcalls and use them on Z80 targets

Author: calc84maniac

llvm/include/llvm/IR/RuntimeLibcalls.def

@@ -189,6 +189,13 @@ HANDLE_LIBCALL(CTLZ_I32, "__clzsi2")
 HANDLE_LIBCALL(CTLZ_I48, nullptr)
 HANDLE_LIBCALL(CTLZ_I64, "__clzdi2")
 HANDLE_LIBCALL(CTLZ_I128, "__clzti2")
+HANDLE_LIBCALL(CTTZ_I8, nullptr)
+HANDLE_LIBCALL(CTTZ_I16, nullptr)
+HANDLE_LIBCALL(CTTZ_I24, nullptr)
+HANDLE_LIBCALL(CTTZ_I32, nullptr)
+HANDLE_LIBCALL(CTTZ_I48, nullptr)
+HANDLE_LIBCALL(CTTZ_I64, nullptr)
+HANDLE_LIBCALL(CTTZ_I128, nullptr)
 HANDLE_LIBCALL(POPCNT_I8, nullptr)
 HANDLE_LIBCALL(POPCNT_I16, nullptr)
 HANDLE_LIBCALL(POPCNT_I24, nullptr)

llvm/lib/Target/Z80/GISel/Z80LegalizerInfo.cpp

@@ -299,11 +299,11 @@ Z80LegalizerInfo::Z80LegalizerInfo(const Z80Subtarget &STI,
        G_USUBSAT, G_SSUBSAT, G_USHLSAT, G_SSHLSAT, G_FPOWI})
       .lower();
 
-  getActionDefinitionsBuilder({G_CTTZ, G_CTTZ_ZERO_UNDEF, G_CTLZ_ZERO_UNDEF})
+  getActionDefinitionsBuilder({G_CTTZ_ZERO_UNDEF, G_CTLZ_ZERO_UNDEF})
       .lowerForCartesianProduct({s8}, LegalLibcallScalars)
       .clampScalar(0, s8, s8);
 
-  getActionDefinitionsBuilder(G_CTLZ)
+  getActionDefinitionsBuilder({G_CTLZ, G_CTTZ})
       .customForCartesianProduct({s8}, LegalLibcallScalars)
       .clampScalar(0, s8, s8);
 
@@ -374,7 +374,8 @@ LegalizerHelper::LegalizeResult Z80LegalizerInfo::legalizeCustomMaybeLegal(
   case G_FCANONICALIZE:
     return legalizeFCanonicalize(Helper, MI);
   case G_CTLZ:
-    return legalizeCtlz(Helper, MI);
+  case G_CTTZ:
+    return legalizeCtz(Helper, MI);
   case G_MEMCPY:
   case G_MEMCPY_INLINE:
   case G_MEMMOVE:
@@ -892,9 +893,9 @@ Z80LegalizerInfo::legalizeFCanonicalize(LegalizerHelper &Helper,
 }
 
 LegalizerHelper::LegalizeResult
-Z80LegalizerInfo::legalizeCtlz(LegalizerHelper &Helper,
-                               MachineInstr &MI) const {
-  assert(MI.getOpcode() == G_CTLZ);
+Z80LegalizerInfo::legalizeCtz(LegalizerHelper &Helper,
+                              MachineInstr &MI) const {
+  assert(MI.getOpcode() == G_CTLZ || MI.getOpcode() == G_CTTZ);
   MachineIRBuilder &MIRBuilder = Helper.MIRBuilder;
   MachineRegisterInfo &MRI = *MIRBuilder.getMRI();
   auto &Ctx = MIRBuilder.getMF().getFunction().getContext();
@@ -910,14 +911,15 @@ Z80LegalizerInfo::legalizeCtlz(LegalizerHelper &Helper,
     return LegalizerHelper::UnableToLegalize;
 
   RTLIB::Libcall Libcall;
+  bool Leading = MI.getOpcode() == G_CTLZ;
   switch (SrcSize) {
   default: return LegalizerHelper::UnableToLegalize;
-  case  8: Libcall = RTLIB::CTLZ_I8 ; break;
-  case 16: Libcall = RTLIB::CTLZ_I16; break;
-  case 24: Libcall = RTLIB::CTLZ_I24; break;
-  case 32: Libcall = RTLIB::CTLZ_I32; break;
-  case 48: Libcall = RTLIB::CTLZ_I48; break;
-  case 64: Libcall = RTLIB::CTLZ_I64; break;
+  case  8: Libcall = Leading ? RTLIB::CTLZ_I8  : RTLIB::CTTZ_I8;  break;
+  case 16: Libcall = Leading ? RTLIB::CTLZ_I16 : RTLIB::CTTZ_I16; break;
+  case 24: Libcall = Leading ? RTLIB::CTLZ_I24 : RTLIB::CTTZ_I24; break;
+  case 32: Libcall = Leading ? RTLIB::CTLZ_I32 : RTLIB::CTTZ_I32; break;
+  case 48: Libcall = Leading ? RTLIB::CTLZ_I48 : RTLIB::CTTZ_I48; break;
+  case 64: Libcall = Leading ? RTLIB::CTLZ_I64 : RTLIB::CTTZ_I64; break;
   }
   auto Result = createLibcall(MIRBuilder, Libcall,
                               {DstReg, IntegerType::get(Ctx, DstSize), 0},

llvm/lib/Target/Z80/GISel/Z80LegalizerInfo.h

@@ -67,8 +67,8 @@ class Z80LegalizerInfo : public LegalizerInfo {
   legalizeMultiplyWithOverflow(LegalizerHelper &Helper, MachineInstr &MI) const;
   LegalizerHelper::LegalizeResult legalizeFCanonicalize(LegalizerHelper &Helper,
                                                         MachineInstr &MI) const;
-  LegalizerHelper::LegalizeResult legalizeCtlz(LegalizerHelper &Helper,
-                                               MachineInstr &MI) const;
+  LegalizerHelper::LegalizeResult legalizeCtz(LegalizerHelper &Helper,
+                                              MachineInstr &MI) const;
   LegalizerHelper::LegalizeResult
   legalizeMemIntrinsic(LegalizerHelper &Helper, MachineInstr &MI,
                        LostDebugLocObserver &LocObserver) const;

llvm/lib/Target/Z80/Z80ISelLowering.cpp

@@ -158,6 +158,12 @@ Z80TargetLowering::Z80TargetLowering(const Z80TargetMachine &TM,
   setLibcall(RTLIB::CTLZ_I32,         "_lctlz",      CallingConv::Z80_LibCall   );
   setLibcall(RTLIB::CTLZ_I48,         "_i48ctlz",    CallingConv::Z80_LibCall   );
   setLibcall(RTLIB::CTLZ_I64,         "_llctlz",     CallingConv::Z80_LibCall   );
+  setLibcall(RTLIB::CTTZ_I8,          "_bcttz",      CallingConv::Z80_LibCall_AC);
+  setLibcall(RTLIB::CTTZ_I16,         "_scttz",      CallingConv::Z80_LibCall   );
+  setLibcall(RTLIB::CTTZ_I24,         "_icttz",      CallingConv::Z80_LibCall   );
+  setLibcall(RTLIB::CTTZ_I32,         "_lcttz",      CallingConv::Z80_LibCall   );
+  setLibcall(RTLIB::CTTZ_I48,         "_i48cttz",    CallingConv::Z80_LibCall   );
+  setLibcall(RTLIB::CTTZ_I64,         "_llcttz",     CallingConv::Z80_LibCall   );
   setLibcall(RTLIB::POPCNT_I8,        "_bpopcnt",    CallingConv::Z80_LibCall_AC);
   setLibcall(RTLIB::POPCNT_I16,       "_spopcnt",    CallingConv::Z80_LibCall   );
   setLibcall(RTLIB::POPCNT_I24,       "_ipopcnt",    CallingConv::Z80_LibCall   );