[NewPM][CodeGen] Add machine code verification callback

[ychen]

Summary

D83608 need this.

[aeubanks]

lgtm with nit

llvm/lib/CodeGen/MachineVerifier.cpp

310

[ychen]

• fix typo

llvm/include/llvm/CodeGen/MachineFunction.h

 };
 template <> struct GraphTraits<Inverse<const MachineFunction*>> :
   public GraphTraits<Inverse<const MachineBasicBlock*>> {
   static NodeRef getEntryNode(Inverse<const MachineFunction *> G) {
     return &G.Graph->front();
   }
 };
 
+class MachineFunctionAnalysisManager;
+void verifyMachineFunction(MachineFunctionAnalysisManager *,
+                           const std::string &Banner,
+                           const MachineFunction &MF);
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEFUNCTION_H

llvm/include/llvm/CodeGen/MachinePassManager.h

 /// - Support codegening in the SCC order. Users include interprocedural
 ///   register allocation (IPRA).
 class MachineFunctionPassManager
     : public PassManager<MachineFunction, MachineFunctionAnalysisManager> {
   using Base = PassManager<MachineFunction, MachineFunctionAnalysisManager>;
 
 public:
   MachineFunctionPassManager(bool DebugLogging = false,
-                             bool RequireCodeGenSCCOrder = false)
-      : Base(DebugLogging), RequireCodeGenSCCOrder(RequireCodeGenSCCOrder) {}
+                             bool RequireCodeGenSCCOrder = false,
+                             bool VerifyMachineFunction = false)
+      : Base(DebugLogging), RequireCodeGenSCCOrder(RequireCodeGenSCCOrder),
+        VerifyMachineFunction(VerifyMachineFunction) {}
   MachineFunctionPassManager(MachineFunctionPassManager &&) = default;
   MachineFunctionPassManager &
   operator=(MachineFunctionPassManager &&) = default;
 
   /// Run machine passes for a Module.
   ///
   /// The intended use is to start the codegen pipeline for a Module. The base
   /// class's `run` method is deliberately hidden by this due to the observation
private:
   SmallVector<llvm::unique_function<FuncTy>, 4> InitializationFuncs;
   SmallVector<llvm::unique_function<FuncTy>, 4> FinalizationFuncs;
 
   using PassIndex = decltype(Passes)::size_type;
   std::map<PassIndex, llvm::unique_function<FuncTy>> MachineModulePasses;
 
   // Run codegen in the SCC order.
   bool RequireCodeGenSCCOrder;
+
+  bool VerifyMachineFunction;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEPASSMANAGER_H

llvm/lib/CodeGen/MachinePassManager.cpp

 //===---------- MachinePassManager.cpp ------------------------------------===//
 //
 // 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 file contains the pass management machinery for machine functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/PassManagerImpl.h"
 
 using namespace llvm;
 
 namespace llvm {
 template class AllAnalysesOn<MachineFunction>;
 template class AnalysisManager<MachineFunction>;
 template class PassManager<MachineFunction>;
 
 Error MachineFunctionPassManager::run(Module &M,
                                       MachineFunctionAnalysisManager &MFAM) {
   // MachineModuleAnalysis is a module analysis pass that is never invalidated
   // because we don't run any module pass in codegen pipeline. This is very
   // important because the codegen state is stored in MMI which is the analysis
   // result of MachineModuleAnalysis. MMI should not be recomputed.
   auto &MMI = MFAM.getResult<MachineModuleAnalysis>(M);
 
   (void)RequireCodeGenSCCOrder;
   assert(!RequireCodeGenSCCOrder && "not implemented");
 
+  // Add a PIC to verify machine functions.
+  if (VerifyMachineFunction) {
+    PassInstrumentation PI = MFAM.getResult<PassInstrumentationAnalysis>(M);
+
+    // No need to pop this callback later since MIR pipeline is flat which means
+    // current pipeline is the top-level pipeline. Callbacks are not used after
+    // current pipeline.
+    PI.pushBeforeNonSkippedPassCallback([&MFAM](StringRef PassID, Any IR) {
+      assert(any_isa<const MachineFunction *>(IR));
+      const MachineFunction *MF = any_cast<const MachineFunction *>(IR);
+      assert(MF && "Machine function should be valid for printing");
+      std::string Banner = std::string("After ") + std::string(PassID);
+      verifyMachineFunction(&MFAM, Banner, *MF);
+    });
+  }
+
   if (DebugLogging) {
     dbgs() << "Starting " << getTypeName<MachineFunction>()
            << " pass manager run.\n";
   }
 
   for (auto &F : InitializationFuncs) {
     if (auto Err = F(M, MFAM))
       return Err;

llvm/lib/CodeGen/MachineVerifier.cpp

 
 INITIALIZE_PASS(MachineVerifierPass, "machineverifier",
                 "Verify generated machine code", false, false)
 
 FunctionPass *llvm::createMachineVerifierPass(const std::string &Banner) {
   return new MachineVerifierPass(Banner);
 }
 
+void llvm::verifyMachineFunction(MachineFunctionAnalysisManager *,
+                                 const std::string &Banner,
+                                 const MachineFunction &MF) {
+  // TODO: Use MFAM after porting below analyses.
+  // LiveVariables *LiveVars;
+  // LiveIntervals *LiveInts;
+  // LiveStacks *LiveStks;
+  // SlotIndexes *Indexes;
+  unsigned FoundErrors = MachineVerifier(nullptr, Banner.c_str()).verify(MF);
+  if (FoundErrors)
+    report_fatal_error("Found " + Twine(FoundErrors) + " machine code errors.");
+}
+
 bool MachineFunction::verify(Pass *p, const char *Banner, bool AbortOnErrors)
     const {
   MachineFunction &MF = const_cast<MachineFunction&>(*this);
   unsigned FoundErrors = MachineVerifier(p, Banner).verify(MF);
   if (AbortOnErrors && FoundErrors)
     report_fatal_error("Found "+Twine(FoundErrors)+" machine code errors.");
   return FoundErrors == 0;
 }