[NewPM] Port FinalizeISel to the new pass manager.

[arsenm]

This was renamed to FinalizeISel

[czhang]

rebase (renamed pass) & clang-format

[czhang]

Rebase

[arsenm]

llvm/include/llvm/CodeGen/FinalizeISel.h

25–30

Should these pass headers be sorted into an include/llvm/CodeGen/Passes directory?

llvm/lib/Passes/PassRegistry.def

320

Machine CSE doesn't belong in this patch?

[czhang]

llvm/include/llvm/CodeGen/FinalizeISel.h

25–30

Since the non-codegen passes in Analysis/ and Transform/ have their equivalent headers under paths corresponding to the implementation files, I think it is better to leave it like this for consistency with the normal IR passes.

[czhang]

Fix misplaced machine-cse.

[arsenm]

Just because the IR passes made a mess of this doesn't mean the same mistake should be repeated for CodeGen passes. I think the clutter of the pass headers should be sorted away to reduce the mental burden of figuring out which headers should be included by machine passes

llvm/lib/CodeGen/CodeGen.cpp

36

No PassPass

llvm/lib/CodeGen/FinalizeISel.cpp

46

Remove pass to avoid PassPass

[czhang]

In D64185#1607313, @arsenm wrote:

Just because the IR passes made a mess of this doesn't mean the same mistake should be repeated for CodeGen passes. I think the clutter of the pass headers should be sorted away to reduce the mental burden of figuring out which headers should be included by machine passes

I definitely hear what you are saying, but for the sake of consistency I believe it would be less confusing if we followed the IR pass convention for now. Then we could discuss potentially cleaning up both the IR pass and CodeGen pass headers at the same time.

[czhang]

llvm/lib/CodeGen/FinalizeISel.cpp

46

Again, for the sake of consistency, it may be less error-prone and confusing for future porters if we stick with the well established convention in having the ugly PassPass stick around for pass registration, ugly as it is. Basically every ported IR pass has a PassPass attached to it and it makes it clear that these are legacy passes. Of course, this probably won't even matter once all the passes are ported since it seems like the goal is to remove the legacy pass manager entirely once the transition is completed.

[arsenm]

llvm/lib/CodeGen/FinalizeISel.cpp

46

This isn't a well established convention. Some passes do, and some don't

llvm/include/llvm/CodeGen/FinalizeISel.h

+//===-- llvm/CodeGen/FinalizeISel.h ----------------------*- C++ -*-===//
+//
+// 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 pass expands Pseudo-instructions produced by ISel, fixes register
+/// reservations and may do machine frame information adjustments.
+/// The pseudo instructions are used to allow the expansion to contain control
+/// flow, such as a conditional move implemented with a conditional branch and a
+/// phi, or an atomic operation implemented with a loop.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_FINALIZE_ISEL_H
+#define LLVM_CODEGEN_FINALIZE_ISEL_H
+
+#include "llvm/CodeGen/PassManager.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct FinalizeISelPass : PassInfoMixin<FinalizeISelPass> {
+  PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &);
+};
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_FINALIZE_ISEL_H

llvm/include/llvm/InitializePasses.h

 void initializeEliminateAvailableExternallyLegacyPassPass(PassRegistry&);
 void initializeEntryExitInstrumenterPass(PassRegistry&);
 void initializeExpandMemCmpPassPass(PassRegistry&);
 void initializeExpandPostRAPass(PassRegistry&);
 void initializeExpandReductionsPass(PassRegistry&);
 void initializeMakeGuardsExplicitLegacyPassPass(PassRegistry&);
 void initializeExternalAAWrapperPassPass(PassRegistry&);
 void initializeFEntryInserterPass(PassRegistry&);
-void initializeFinalizeISelPass(PassRegistry&);
+void initializeFinalizeISelLegacyPassPass(PassRegistry&);
 void initializeFinalizeMachineBundlesPass(PassRegistry&);
 void initializeFlattenCFGPassPass(PassRegistry&);
 void initializeFloat2IntLegacyPassPass(PassRegistry&);
 void initializeForceFunctionAttrsLegacyPassPass(PassRegistry&);
 void initializeForwardControlFlowIntegrityPass(PassRegistry&);
 void initializeFuncletLayoutPass(PassRegistry&);
 void initializeFunctionImportLegacyPassPass(PassRegistry&);
 void initializeGCMachineCodeAnalysisPass(PassRegistry&);

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeDetectDeadLanesPass(Registry);
   initializeDwarfEHPreparePass(Registry);
   initializeEarlyIfConverterPass(Registry);
   initializeEarlyMachineLICMPass(Registry);
   initializeEarlyTailDuplicatePass(Registry);
   initializeExpandMemCmpPassPass(Registry);
   initializeExpandPostRAPass(Registry);
   initializeFEntryInserterPass(Registry);
-  initializeFinalizeISelPass(Registry);
+  initializeFinalizeISelLegacyPassPass(Registry);
   initializeFinalizeMachineBundlesPass(Registry);
   initializeFuncletLayoutPass(Registry);
   initializeGCMachineCodeAnalysisPass(Registry);
   initializeGCModuleInfoPass(Registry);
   initializeHardwareLoopsPass(Registry);
   initializeIfConverterPass(Registry);
   initializeImplicitNullChecksPass(Registry);
   initializeIndirectBrExpandPassPass(Registry);

llvm/lib/CodeGen/FinalizeISel.cpp

 //===-- llvm/CodeGen/FinalizeISel.cpp ---------------------------*- C++ -*-===//
 //
 // 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 pass expands Pseudo-instructions produced by ISel, fixes register
 /// reservations and may do machine frame information adjustments.
 /// The pseudo instructions are used to allow the expansion to contain control
 /// flow, such as a conditional move implemented with a conditional branch and a
 /// phi, or an atomic operation implemented with a loop.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/CodeGen/FinalizeISel.h"
+
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/Support/Debug.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "finalize-isel"
 
 namespace {
-  class FinalizeISel : public MachineFunctionPass {
-  public:
-    static char ID; // Pass identification, replacement for typeid
-    FinalizeISel() : MachineFunctionPass(ID) {}
+class FinalizeISelLegacyPass : public MachineFunctionPass {
+  FinalizeISelLegacyPass() : MachineFunctionPass(ID) {}
 
   private:
     bool runOnMachineFunction(MachineFunction &MF) override;
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       MachineFunctionPass::getAnalysisUsage(AU);
     }
   };
 } // end anonymous namespace
 
-char FinalizeISel::ID = 0;
-char &llvm::FinalizeISelID = FinalizeISel::ID;
-INITIALIZE_PASS(FinalizeISel, DEBUG_TYPE,
+char FinalizeISelLegacyPass::ID = 0;
+char &llvm::FinalizeISelID = FinalizeISelLegacyPass::ID;
+INITIALIZE_PASS(FinalizeISelLegacyPass, DEBUG_TYPE,
                 "Finalize ISel and expand pseudo-instructions", false, false)
 
-bool FinalizeISel::runOnMachineFunction(MachineFunction &MF) {
+static bool finalizeISel(MachineFunction &MF) {
   bool Changed = false;
   const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
 
   // Iterate through each instruction in the function, looking for pseudos.
   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
     MachineBasicBlock *MBB = &*I;
     for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
          MBBI != MBBE; ) {
for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
       }
     }
   }
 
   TLI->finalizeLowering(MF);
 
   return Changed;
 }
+
+PreservedAnalyses FinalizeISelPass::run(MachineFunction &MF,
+                                        MachineFunctionAnalysisManager &) {
+  return finalizeISel(MF) ? PreservedAnalyses::all()
+                          : PreservedAnalyses::none();
+}
+
+bool FinalizeISelLegacyPass::runOnMachineFunction(MachineFunction &MF) {
+  return finalizeISel(MF);
+}

llvm/lib/Passes/PassRegistry.def

LOOP_PASS_WITH_PARAMS("unswitch",
                              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())
+MACHINE_FUNCTION_PASS("finalize-isel", FinalizeISelPass())
+MACHINE_FUNCTION_PASS("machine-cse", MachineCSEPass())
 #undef MACHINE_FUNCTION_PASS