[MachineCopyPropagation] More robust isForwardableRegClassCopy

[foad]

Summary

Change the implementation of isForwardableRegClassCopy so that it
does not rely on getMinimalPhysRegClass. Instead, iterate over all
classes looking for any that satisfy a required property.

NFCI on current upstream targets, but this copes better with
downstream AMDGPU changes where some new smaller classes have been
introduced, which was breaking regclass equality tests in the old
code like:

if (UseDstRC != CrossCopyRC && CopyDstRC == CrossCopyRC)

[Joe_Nash]

LGTM

[foad]

In D121903#3389420, @Joe_Nash wrote:

LGTM

Thanks. I'd still like to hear from @vangthao or others who were involved in D108011.

[vangthao]

Would this disallow AGPR to AGPR copy propagation completely on sub-targets with no AGPR->AGPR copy capability? I think in some cases we can still propagate an AGPR. For example:

liveins: $agpr0
  $agpr1 = COPY $agpr0
  $agpr2 = COPY $agpr1
  $agpr3 = COPY $agpr2

$agpr0 can be propagated and we would not require more than 1 set of v_accvgpr_read/write when expanding the copys.

[foad]

Rebase.

[foad]

Would this disallow AGPR to AGPR copy propagation completely on sub-targets with no AGPR->AGPR copy capability?

You're right, it does. I have added a test case for this and rebased the patch to show the effect. I will work on this.

[foad]

Allow the forwarded copy to be cross-class, but only if the original copy was cross-class.

[vangthao]

LGTM.

llvm/lib/CodeGen/MachineCopyPropagation.cpp

bool MachineCopyPropagation::isForwardableRegClassCopy(const MachineInstr &Copy,
   // forwarding.
   if (const TargetRegisterClass *URC =
           UseI.getRegClassConstraint(UseIdx, TII, TRI))
     return URC->contains(CopySrcReg);
 
   if (!UseI.isCopy())
     return false;
 
-  const TargetRegisterClass *CopySrcRC =
-      TRI->getMinimalPhysRegClass(CopySrcReg);
-  const TargetRegisterClass *UseDstRC =
-      TRI->getMinimalPhysRegClass(UseI.getOperand(0).getReg());
-  const TargetRegisterClass *CrossCopyRC = TRI->getCrossCopyRegClass(CopySrcRC);
-
-  // If cross copy register class is not the same as copy source register class
-  // then it is not possible to copy the register directly and requires a cross
-  // register class copy. Fowarding this copy without checking register class of
-  // UseDst may create additional cross register copies when expanding the copy
-  // instruction in later passes.
-  if (CopySrcRC != CrossCopyRC) {
-    const TargetRegisterClass *CopyDstRC =
-        TRI->getMinimalPhysRegClass(Copy.getOperand(0).getReg());
-
-    // Check if UseDstRC matches the necessary register class to copy from
-    // CopySrc's register class. If so then forwarding the copy will not
-    // introduce any cross-class copys. Else if CopyDstRC matches then keep the
-    // copy and do not forward. If neither UseDstRC or CopyDstRC matches then
-    // we may need a cross register copy later but we do not worry about it
-    // here.
-    if (UseDstRC != CrossCopyRC && CopyDstRC == CrossCopyRC)
-      return false;
-  }
-
   /// COPYs don't have register class constraints, so if the user instruction
   /// is a COPY, we just try to avoid introducing additional cross-class
   /// COPYs.  For example:
   ///
   ///   RegClassA = COPY RegClassB  // Copy parameter
   ///   ...
   ///   RegClassB = COPY RegClassA  // UseI parameter
   ///
   /// which after forwarding becomes
   ///
   ///   RegClassA = COPY RegClassB
   ///   ...
   ///   RegClassB = COPY RegClassB
   ///
   /// so we have reduced the number of cross-class COPYs and potentially
   /// introduced a nop COPY that can be removed.
-  const TargetRegisterClass *SuperRC = UseDstRC;
-  for (TargetRegisterClass::sc_iterator SuperRCI = UseDstRC->getSuperClasses();
-       SuperRC; SuperRC = *SuperRCI++)
-    if (SuperRC->contains(CopySrcReg))
-      return true;
 
+  // Allow forwarding if src and dst belong to any common class, so long as they
+  // don't belong to any (possibly smaller) common class that requires copies to
+  // go via a different class.
+  Register UseDstReg = UseI.getOperand(0).getReg();
+  bool Found = false;
+  for (const TargetRegisterClass *RC : TRI->regclasses()) {
+    if (RC->contains(CopySrcReg) && RC->contains(UseDstReg)) {
+      if (TRI->getCrossCopyRegClass(RC) != RC)
         return false;
+      Found = true;
+    }
+  }
+  return Found;
 }
 
 /// Check that \p MI does not have implicit uses that overlap with it's \p Use
 /// operand (the register being replaced), since these can sometimes be
 /// implicitly tied to other operands.  For example, on AMDGPU:
 ///
 /// V_MOVRELS_B32_e32 %VGPR2, %M0<imp-use>, %EXEC<imp-use>, %VGPR2_VGPR3_VGPR4_VGPR5<imp-use>
 ///