Avoid TLI.getSupportedLibcallImpl

Rewrite to check a (much smaller) list of libcalls

Author: MacDue

llvm/lib/Target/AArch64/AArch64FrameLowering.cpp

@@ -1475,27 +1475,25 @@ static bool requiresSaveVG(const MachineFunction &MF) {
   return true;
 }
 
-bool isVGInstruction(MachineBasicBlock::iterator MBBI) {
+static bool matchLibcall(const TargetLowering &TLI, const MachineOperand &MO,
+                         RTLIB::Libcall LC) {
+  return MO.isSymbol() && TLI.getLibcallName(LC) == MO.getSymbolName();
+}
+
+bool isVGInstruction(MachineBasicBlock::iterator MBBI,
+                     const TargetLowering &TLI) {
   unsigned Opc = MBBI->getOpcode();
   if (Opc == AArch64::CNTD_XPiI || Opc == AArch64::RDSVLI_XI ||
       Opc == AArch64::UBFMXri)
     return true;
 
-  if (requiresGetVGCall(*MBBI->getMF())) {
-    if (Opc == AArch64::ORRXrr)
-      return true;
+  if (!requiresGetVGCall(*MBBI->getMF()))
+    return false;
 
-    if (Opc == AArch64::BL) {
-      auto Op1 = MBBI->getOperand(0);
-      auto &TLI =
-          *MBBI->getMF()->getSubtarget<AArch64Subtarget>().getTargetLowering();
-      char const *GetCurrentVG =
-          TLI.getLibcallName(RTLIB::SMEABI_GET_CURRENT_VG);
-      return Op1.isSymbol() && StringRef(Op1.getSymbolName()) == GetCurrentVG;
-    }
-  }
+  if (Opc == AArch64::BL)
+    return matchLibcall(TLI, MBBI->getOperand(0), RTLIB::SMEABI_GET_CURRENT_VG);
 
-  return false;
+  return Opc == AArch64::ORRXrr;
 }
 
 // Convert callee-save register save/restore instruction to do stack pointer
@@ -1514,9 +1512,11 @@ static MachineBasicBlock::iterator convertCalleeSaveRestoreToSPPrePostIncDec(
   // functions, we need to do this for both the streaming and non-streaming
   // vector length. Move past these instructions if necessary.
   MachineFunction &MF = *MBB.getParent();
-  if (requiresSaveVG(MF))
-    while (isVGInstruction(MBBI))
+  if (requiresSaveVG(MF)) {
+    auto &TLI = *MF.getSubtarget().getTargetLowering();
+    while (isVGInstruction(MBBI, TLI))
       ++MBBI;
+  }
 
   switch (MBBI->getOpcode()) {
   default:
@@ -2100,11 +2100,12 @@ void AArch64FrameLowering::emitPrologue(MachineFunction &MF,
   // Move past the saves of the callee-saved registers, fixing up the offsets
   // and pre-inc if we decided to combine the callee-save and local stack
   // pointer bump above.
+  auto &TLI = *MF.getSubtarget().getTargetLowering();
   while (MBBI != End && MBBI->getFlag(MachineInstr::FrameSetup) &&
          !IsSVECalleeSave(MBBI)) {
     if (CombineSPBump &&
         // Only fix-up frame-setup load/store instructions.
-        (!requiresSaveVG(MF) || !isVGInstruction(MBBI)))
+        (!requiresSaveVG(MF) || !isVGInstruction(MBBI, TLI)))
       fixupCalleeSaveRestoreStackOffset(*MBBI, AFI->getLocalStackSize(),
                                         NeedsWinCFI, &HasWinCFI);
     ++MBBI;

llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.cpp

@@ -81,34 +81,40 @@ SMEAttrs::SMEAttrs(const AttributeList &Attrs) {
 
 void SMEAttrs::addKnownFunctionAttrs(StringRef FuncName,
                                      const TargetLowering &TLI) {
-  RTLIB::LibcallImpl Impl = TLI.getSupportedLibcallImpl(FuncName);
-  if (Impl == RTLIB::Unsupported)
-    return;
-  RTLIB::Libcall LC = RTLIB::RuntimeLibcallsInfo::getLibcallFromImpl(Impl);
+  struct SMERoutineAttr {
+    RTLIB::Libcall LC{RTLIB::UNKNOWN_LIBCALL};
+    unsigned Attrs{SMEAttrs::Normal};
+  };
+
+  static constexpr unsigned SMCompatiableABIRoutine =
+      SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine;
+  static constexpr unsigned SMCompatiableABIRoutineInZA =
+      SMCompatiableABIRoutine | encodeZAState(StateValue::In);
+
+  // Table of SME routine -> Known attributes.
+  static constexpr SMERoutineAttr SMERoutineAttrs[]{
+      {RTLIB::SMEABI_SME_STATE, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_TPIDR2_SAVE, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_GET_CURRENT_VG, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_SME_STATE_SIZE, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_SME_SAVE, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_SME_RESTORE, SMCompatiableABIRoutine},
+      {RTLIB::SMEABI_ZA_DISABLE, SMCompatiableABIRoutineInZA},
+      {RTLIB::SMEABI_TPIDR2_RESTORE, SMCompatiableABIRoutineInZA},
+      {RTLIB::SC_MEMCPY, SMEAttrs::SM_Compatible},
+      {RTLIB::SC_MEMMOVE, SMEAttrs::SM_Compatible},
+      {RTLIB::SC_MEMSET, SMEAttrs::SM_Compatible},
+      {RTLIB::SC_MEMCHR, SMEAttrs::SM_Compatible},
+  };
+
   unsigned KnownAttrs = SMEAttrs::Normal;
-  switch (LC) {
-  case RTLIB::SMEABI_SME_STATE:
-  case RTLIB::SMEABI_TPIDR2_SAVE:
-  case RTLIB::SMEABI_GET_CURRENT_VG:
-  case RTLIB::SMEABI_SME_STATE_SIZE:
-  case RTLIB::SMEABI_SME_SAVE:
-  case RTLIB::SMEABI_SME_RESTORE:
-    KnownAttrs |= SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine;
-    break;
-  case RTLIB::SMEABI_ZA_DISABLE:
-  case RTLIB::SMEABI_TPIDR2_RESTORE:
-    KnownAttrs |= SMEAttrs::SM_Compatible | encodeZAState(StateValue::In) |
-                  SMEAttrs::SME_ABI_Routine;
-    break;
-  case RTLIB::SC_MEMCPY:
-  case RTLIB::SC_MEMMOVE:
-  case RTLIB::SC_MEMSET:
-  case RTLIB::SC_MEMCHR:
-    KnownAttrs |= SMEAttrs::SM_Compatible;
-    break;
-  default:
-    break;
+  for (auto [LC, Attrs] : SMERoutineAttrs) {
+    if (TLI.getLibcallName(LC) == FuncName) {
+      KnownAttrs = Attrs;
+      break;
+    }
   }
+
   set(KnownAttrs);
 }
 

llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.h

@@ -84,7 +84,7 @@ class SMEAttrs {
   static StateValue decodeZAState(unsigned Bitmask) {
     return static_cast<StateValue>((Bitmask & ZA_Mask) >> ZA_Shift);
   }
-  static unsigned encodeZAState(StateValue S) {
+  static constexpr unsigned encodeZAState(StateValue S) {
     return static_cast<unsigned>(S) << ZA_Shift;
   }