Can we track all of this in regunits? Following registers is way more confusing

I don't see how SrcRegs is used any differently. Should this just use a more normal looking liveness scan where there's only one set and each def removes the live uses?

Leftover?

I don't see how SrcRegs is used any differently.

MCP currently works s.t. if a source or dest of some MI partially overlaps the source or dest of an active, then we say that the copy is no longer active across all its def regunits. In other words, we don't allow partial copy propagation. This is what Copy.DefRegs is used for, if we come across an MI with regunit that partially overlaps with some previous copy, we query the map to get the Copy structure, then we invalidate it for all the RegUnit in Def where Def is just the dest register in the actual copy.

However, we don't do the same for the src RegUnits of the copy. Enabling such is the intention behind Copy.SrcRegs. As is, if an MI has registers (B) which partially overlaps the source of a Copy (A), a subsequent MI will find that Copy is still active if it has registers that are in the difference A - B.

In short, Copy.SrcRegs holds the Source Reg of the copy, so that when we mark a copy as invalid, we can do so across all regunits in its source.

Should this just use a more normal looking liveness scan where there's only one set and each def removes the live uses

The tracker for backwardCopyProp really needs to track 3 things:

1. "Activeness" of the uses of the copies. This is really just liveness, however any partial clobbering should say the full set of RegUnits involved in the use is inactive.
2. Validity of propagation --
   1. Uses of copy uses - if we want to propagate a copy backwards, then we will replace DEF A; B = COPY A with -> DEF B. But, if there are any uses of A between the DEF and the COPY then the propagation is not longer valid.
   2. Uses of copy defs - If we have done the above propagation, and there is a user of B between the propagation site and the COPY, then we will have clobbered.

I think we can identify 1 and 2A with a tracker that does something that looks like a backwards liveness scan, however, I don't think we can capture 2B.

diff
@@ -137,18 +137,20 @@ public:
     // and invalidate all of them.
     SmallSet<MCRegister, 8> RegsToInvalidate;
     RegsToInvalidate.insert(Reg);
+    auto invalidate = [&](MachineInstr *MI) {
+      std::optional<DestSourcePair> CopyOperands =
+          isCopyInstr(*MI, TII, UseCopyInstr);
+      assert(CopyOperands && "Expect copy");
+      RegsToInvalidate.insert(CopyOperands->Destination->getReg().asMCReg());
+      RegsToInvalidate.insert(CopyOperands->Source->getReg().asMCReg());
+    };
     for (MCRegUnit Unit : TRI.regunits(Reg)) {
       auto I = Copies.find(Unit);
       if (I != Copies.end()) {
-        if (MachineInstr *MI = I->second.MI) {
-          std::optional<DestSourcePair> CopyOperands =
-              isCopyInstr(*MI, TII, UseCopyInstr);
-          assert(CopyOperands && "Expect copy");
-
-          RegsToInvalidate.insert(
-              CopyOperands->Destination->getReg().asMCReg());
-          RegsToInvalidate.insert(CopyOperands->Source->getReg().asMCReg());
-        }
+        if (MachineInstr *MI = I->second.MI)
+          invalidate(MI);
+        if (MachineInstr *MI = I->second.LastSeenUseInCopy)
+          invalidate(MI);
         RegsToInvalidate.insert(I->second.DefRegs.begin(),
                                 I->second.DefRegs.end());
       }

We should check both of I->second.MI and I->second.LastSeenUseInCopy.

I agree with that we should track at regunit basis. Maybe we can do that in another NFC patch.