[NewPM] Port MachineCopyPropagation to the new pass manager.

[czhang]

rebase & clang-format

[probinson]

Minor drive-by stylistic points. Someone who knows what's going on with passes should look at this.

llvm/include/llvm/CodeGen/MachineCopyPropagation.h

1

This line needs the 'C++' tag, see any other .h file for an example.

llvm/lib/CodeGen/CodeGen.cpp

62

This wants to stay in alphabetical order.

llvm/lib/CodeGen/MachineCopyPropagation.cpp

634

Did you mean for this to be a static function?

llvm/lib/Passes/PassRegistry.def

315

Based on the style in this file, there wants to be a blank line before the '#ifndef'.

[czhang]

Rebase & address style comments.

[czhang]

another style comment

llvm/include/llvm/CodeGen/MachineCopyPropagation.h

+//===- MachineCopyPropagation.h - Machine Copy Propagation Pass ---------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is an extremely simple MachineInstr-level copy propagation pass.
+//
+// This pass forwards the source of COPYs to the users of their destinations
+// when doing so is legal.  For example:
+//
+//   %reg1 = COPY %reg0
+//   ...
+//   ... = OP %reg1
+//
+// If
+//   - %reg0 has not been clobbered by the time of the use of %reg1
+//   - the register class constraints are satisfied
+//   - the COPY def is the only value that reaches OP
+// then this pass replaces the above with:
+//
+//   %reg1 = COPY %reg0
+//   ...
+//   ... = OP %reg0
+//
+// This pass also removes some redundant COPYs.  For example:
+//
+//    %R1 = COPY %R0
+//    ... // No clobber of %R1
+//    %R0 = COPY %R1 <<< Removed
+//
+// or
+//
+//    %R1 = COPY %R0
+//    ... // No clobber of %R0
+//    %R1 = COPY %R0 <<< Removed
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINE_COPY_PROPAGATION_H
+#define LLVM_CODEGEN_MACHINE_COPY_PROPAGATION_H
+
+#include "llvm/CodeGen/PassManager.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+// The Machine Copy Propagation pass.
+struct MachineCopyPropagationPass : PassInfoMixin<MachineCopyPropagationPass> {
+  PreservedAnalyses run(MachineFunction &MF,
+                        MachineFunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINE_COPY_PROPAGATION_H

llvm/include/llvm/InitializePasses.h

 void initializeMIRCanonicalizerPass(PassRegistry &);
 void initializeMIRPrintingPassPass(PassRegistry &);
 void initializeMachineBlockFrequencyInfoPass(PassRegistry&);
 void initializeMachineBlockPlacementPass(PassRegistry&);
 void initializeMachineBlockPlacementStatsPass(PassRegistry&);
 void initializeMachineBranchProbabilityInfoPass(PassRegistry&);
 void initializeMachineCSEPass(PassRegistry &);
 void initializeMachineCombinerPass(PassRegistry&);
-void initializeMachineCopyPropagationPass(PassRegistry &);
+void initializeMachineCopyPropagationLegacyPassPass(PassRegistry &);
 void initializeMachineDominanceFrontierPass(PassRegistry&);
 void initializeMachineDominatorTreePass(PassRegistry &);
 void initializeMachineFunctionPrinterPassPass(PassRegistry&);
 void initializeMachineLICMPass(PassRegistry&);
 void initializeMachineLoopInfoPass(PassRegistry&);
 void initializeMachineModuleInfoWrapperPassPass(PassRegistry &);
 void initializeMachineOptimizationRemarkEmitterPassPass(PassRegistry&);
 void initializeMachineOutlinerPass(PassRegistry&);

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeLocalStackSlotPassPass(Registry);
   initializeLowerIntrinsicsPass(Registry);
   initializeMIRCanonicalizerPass(Registry);
   initializeMachineBlockFrequencyInfoPass(Registry);
   initializeMachineBlockPlacementPass(Registry);
   initializeMachineBlockPlacementStatsPass(Registry);
   initializeMachineCSEPass(Registry);
   initializeMachineCombinerPass(Registry);
-  initializeMachineCopyPropagationPass(Registry);
   initializeMachineDominatorTreePass(Registry);
+  initializeMachineCopyPropagationLegacyPassPass(Registry);
   initializeMachineFunctionPrinterPassPass(Registry);
   initializeMachineLICMPass(Registry);
   initializeMachineLoopInfoPass(Registry);
   initializeMachineModuleInfoWrapperPassPass(Registry);
   initializeMachineOptimizationRemarkEmitterPassPass(Registry);
   initializeMachineOutlinerPass(Registry);
   initializeMachinePipelinerPass(Registry);
   initializeMachinePostDominatorTreePass(Registry);

llvm/lib/CodeGen/MachineCopyPropagation.cpp

 // or
 //
 //    %R1 = COPY %R0
 //    ... // No clobber of %R0
 //    %R1 = COPY %R0 <<< Removed
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/CodeGen/MachineCopyPropagation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
MachineInstr *findAvailCopy(MachineInstr &DestCopy, unsigned Reg,
     return AvailCopy;
   }
 
   void clear() {
     Copies.clear();
   }
 };
 
-class MachineCopyPropagation : public MachineFunctionPass {
-  const TargetRegisterInfo *TRI;
-  const TargetInstrInfo *TII;
-  const MachineRegisterInfo *MRI;
-
+class MachineCopyPropagationLegacyPass : public MachineFunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
-
-  MachineCopyPropagation() : MachineFunctionPass(ID) {
-    initializeMachineCopyPropagationPass(*PassRegistry::getPassRegistry());
+  MachineCopyPropagationLegacyPass() : MachineFunctionPass(ID) {
+    initializeMachineCopyPropagationLegacyPassPass(
+        *PassRegistry::getPassRegistry());
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesCFG();
     MachineFunctionPass::getAnalysisUsage(AU);
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
   MachineFunctionProperties getRequiredProperties() const override {
     return MachineFunctionProperties().set(
         MachineFunctionProperties::Property::NoVRegs);
   }
+};
+
+class MachineCopyPropagation {
+  const TargetRegisterInfo *TRI;
+  const TargetInstrInfo *TII;
+  const MachineRegisterInfo *MRI;
+
+public:
+  bool Changed;
+  MachineCopyPropagation(const TargetRegisterInfo *TRI,
+                         const TargetInstrInfo *TII,
+                         const MachineRegisterInfo *MRI)
+      : TRI(TRI), TII(TII), MRI(MRI), Changed(false) {}
+  void CopyPropagateBlock(MachineBasicBlock &MBB);
 
 private:
   void ClobberRegister(unsigned Reg);
   void ReadRegister(unsigned Reg);
-  void CopyPropagateBlock(MachineBasicBlock &MBB);
   bool eraseIfRedundant(MachineInstr &Copy, unsigned Src, unsigned Def);
   void forwardUses(MachineInstr &MI);
   bool isForwardableRegClassCopy(const MachineInstr &Copy,
                                  const MachineInstr &UseI, unsigned UseIdx);
   bool hasImplicitOverlap(const MachineInstr &MI, const MachineOperand &Use);
 
   /// Candidates for deletion.
   SmallSetVector<MachineInstr *, 8> MaybeDeadCopies;
 
   CopyTracker Tracker;
-
-  bool Changed;
 };
 
 } // end anonymous namespace
 
-char MachineCopyPropagation::ID = 0;
+char MachineCopyPropagationLegacyPass::ID = 0;
 
-char &llvm::MachineCopyPropagationID = MachineCopyPropagation::ID;
+char &llvm::MachineCopyPropagationID = MachineCopyPropagationLegacyPass::ID;
 
-INITIALIZE_PASS(MachineCopyPropagation, DEBUG_TYPE,
+INITIALIZE_PASS(MachineCopyPropagationLegacyPass, DEBUG_TYPE,
                 "Machine Copy Propagation Pass", false, false)
 
 void MachineCopyPropagation::ReadRegister(unsigned Reg) {
   // If 'Reg' is defined by a copy, the copy is no longer a candidate
   // for elimination.
   for (MCRegUnitIterator RUI(Reg, TRI); RUI.isValid(); ++RUI) {
     if (MachineInstr *Copy = Tracker.findCopyForUnit(*RUI, *TRI)) {
       LLVM_DEBUG(dbgs() << "MCP: Copy is used - not dead: "; Copy->dump());
for (MachineInstr *MaybeDead : MaybeDeadCopies) {
       ++NumDeletes;
     }
   }
 
   MaybeDeadCopies.clear();
   Tracker.clear();
 }
 
-bool MachineCopyPropagation::runOnMachineFunction(MachineFunction &MF) {
-  if (skipFunction(MF.getFunction()))
-    return false;
+MachineCopyPropagation copyPropagate(MachineFunction &MF) {
+  MachineCopyPropagation info{MF.getSubtarget().getRegisterInfo(),
+                              MF.getSubtarget().getInstrInfo(),
+                              &MF.getRegInfo()};
 
-  Changed = false;
+  for (MachineBasicBlock &MBB : MF)
+    info.CopyPropagateBlock(MBB);
 
-  TRI = MF.getSubtarget().getRegisterInfo();
-  TII = MF.getSubtarget().getInstrInfo();
-  MRI = &MF.getRegInfo();
+  return info;
+}
 
-  for (MachineBasicBlock &MBB : MF)
-    CopyPropagateBlock(MBB);
+PreservedAnalyses
+MachineCopyPropagationPass::run(MachineFunction &MF,
+                                MachineFunctionAnalysisManager &AM) {
+  return copyPropagate(MF).Changed ? PreservedAnalyses::all()
+                                   : PreservedAnalyses::none();
+}
 
-  return Changed;
+bool MachineCopyPropagationLegacyPass::runOnMachineFunction(
+    MachineFunction &MF) {
+  if (skipFunction(MF.getFunction()))
+    return false;
+  return copyPropagate(MF).Changed;
 }

llvm/lib/Passes/PassRegistry.def

 #define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 #endif
 LOOP_PASS_WITH_PARAMS("unswitch",
                            [](bool NonTrivial) {
                              return SimpleLoopUnswitchPass(NonTrivial);
                            },
                            parseLoopUnswitchOptions)
 #undef LOOP_PASS_WITH_PARAMS
+#ifndef MACHINE_FUNCTION_PASS
+#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
+#endif
+MACHINE_FUNCTION_PASS("machine-cp", MachineCopyPropagationPass())
+#undef MACHINE_FUNCTION_PASS