Stop IR Dumps occurring after MachineVerifier

[dsanders]

Summary

-print-after-all and -print-before-all print after/before each pass.
Unfortunately this includes the MachineVerifier which doesn't make
any changes or produce any information. The end result is that one of these
options in combination with -verify-machineinstrs cause identical MIR to be
dumped twice for each pass (four times if you use both).

I'm not very familiar with the Pass manager infrastructure but this hack
introduces the concept of a verifier pass which does not trigger additional
IR Dumps.

[dsanders]

This probably isn't the right way to go about it as it's adding to Pass rather than PassInfo but hopefully someone more familiar with this area can point me in the right direction.

[czhang]

Seems like the same reasoning could apply to any type of immutable pass, not just verifier passes. It seems a little ad-hoc to single out the machine verifier pass for IR dumping. The benefit of treating all immutable passes this way is that one can simply disable printing based on class.

[dsanders]

In D64681#1597639, @czhang wrote:

Seems like the same reasoning could apply to any type of immutable pass, not just verifier passes. It seems a little ad-hoc to single out the machine verifier pass for IR dumping. The benefit of treating all immutable passes this way is that one can simply disable printing based on class.

I agree but ImmutablePasses already avoid printing the IR as they go into the if-statement on line 775 which returns on line 784 before we get to the code that adds the printers. MachineVerifierPass is somewhat special in that it has the effect of an ImmutablePass but needs to be run like a normal pass. It's a MachineFunctionPass so that it's inserted between each pass without needing anyone/everyone to call getAnalysis<MachineVerifierPass>() and it can't be skipped by setPreservesAll() like an ImmutablePass can. However, it doesn't actually change the IR so it doesn't make sense to print the IR before/after it like other MachineFunctionPasses.

include/llvm/Pass.h

public:
   template<typename AnalysisType>
   AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
 
   template<typename AnalysisType>
   AnalysisType &getAnalysisID(AnalysisID PI) const;
 
   template<typename AnalysisType>
   AnalysisType &getAnalysisID(AnalysisID PI, Function &F);
+
+  virtual bool isVerifier() const { return false; }
 };
 
 //===----------------------------------------------------------------------===//
 /// ModulePass class - This class is used to implement unstructured
 /// interprocedural optimizations and analyses.  ModulePasses may do anything
 /// they want to the program.
 ///
 class ModulePass : public Pass {

lib/CodeGen/MachineVerifier.cpp

struct MachineVerifierPass : public MachineFunctionPass {
     }
 
     bool runOnMachineFunction(MachineFunction &MF) override {
       unsigned FoundErrors = MachineVerifier(this, Banner.c_str()).verify(MF);
       if (FoundErrors)
         report_fatal_error("Found "+Twine(FoundErrors)+" machine code errors.");
       return false;
     }
+
+    bool isVerifier() const override { return true; }
   };
 
 } // end anonymous namespace
 
 char MachineVerifierPass::ID = 0;
 
 INITIALIZE_PASS(MachineVerifierPass, "machineverifier",
                 "Verify generated machine code", false, false)

lib/IR/LegacyPassManager.cpp

if (ImmutablePass *IP = P->getAsImmutablePass()) {
     AnalysisResolver *AR = new AnalysisResolver(*DM);
     P->setResolver(AR);
     DM->initializeAnalysisImpl(P);
     addImmutablePass(IP);
     DM->recordAvailableAnalysis(IP);
     return;
   }
 
-  if (PI && !PI->isAnalysis() && shouldPrintBeforePass(PI->getPassArgument())) {
+  if (!P->isVerifier() && PI && !PI->isAnalysis() &&
+      shouldPrintBeforePass(PI->getPassArgument())) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump Before " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
 
   // Add the requested pass to the best available pass manager.
   P->assignPassManager(activeStack, getTopLevelPassManagerType());
 
-  if (PI && !PI->isAnalysis() && shouldPrintAfterPass(PI->getPassArgument())) {
+  if (!P->isVerifier() && PI && !PI->isAnalysis() &&
+      shouldPrintAfterPass(PI->getPassArgument())) {
     Pass *PP = P->createPrinterPass(
         dbgs(), ("*** IR Dump After " + P->getPassName() + " ***").str());
     PP->assignPassManager(activeStack, getTopLevelPassManagerType());
   }
 }
 
 /// Find the pass that implements Analysis AID. Search immutable
 /// passes and all pass managers. If desired pass is not found