[opt] Do not add verify pass at beginning of pipeline

[aeubanks]

Summary

We've already verified the input module manually in opt so this is redundant.

[aeubanks]

depends on D139898

[bjope]

LGTM

llvm/test/Other/ChangePrinters/print-changed-diff.ll

 define i32 @f() {
 entry:
   %a = add i32 2, 3
   ret i32 %a
 }
 
 ; CHECK-DIFF-SIMPLE: *** IR Dump At Start ***
 ; CHECK-DIFF-SIMPLE: ModuleID = {{.+}}
-; CHECK-DIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
 ; CHECK-DIFF-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-DIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-DIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-DIFF-SIMPLE: entry:
 ; CHECK-DIFF-SIMPLE-NEXT:-  %a = add i32 2, 3
 ; CHECK-DIFF-SIMPLE-NEXT:-  ret i32 %a
 ; CHECK-DIFF-SIMPLE-NEXT:+  ret i32 5
 ; CHECK-DIFF-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***

 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC: entry:
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC:-  %a = add i32 2, 3
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC:-  ret i32 %a
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC:+  ret i32 5
 ; CHECK-DIFF-QUIET-MULT-PASSES-FILTER-FUNC-NOT: *** IR
 
 ; CHECK-CDIFF-SIMPLE: *** IR Dump At Start ***
 ; CHECK-CDIFF-SIMPLE: ModuleID = {{.+}}
-; CHECK-CDIFF-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
 ; CHECK-CDIFF-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-CDIFF-SIMPLE-NOT: ModuleID = {{.+}}
 ; CHECK-CDIFF-SIMPLE-NOT: *** IR{{.*}}
 ; CHECK-CDIFF-SIMPLE: entry:
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  %a = add i32 2, 3{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[31m-}}  ret i32 %a{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE-NEXT:{{.\[32m\+}}  ret i32 5{{.\[0m}}
 ; CHECK-CDIFF-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***

llvm/test/Other/change-printer.ll

 define i32 @f() {
 entry:
   %a = add i32 2, 3
   ret i32 %a
 }
 
 ; CHECK-SIMPLE: *** IR Dump At Start ***
 ; CHECK-SIMPLE-NEXT: ; ModuleID = {{.+}}
-; CHECK-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***
 ; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-SIMPLE-NEXT: define i32 @g()
 ; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} on g ignored ***
 ; CHECK-SIMPLE: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-SIMPLE-NEXT: define i32 @f()
 ; CHECK-SIMPLE: *** IR Pass PassManager{{.*}} on f ignored ***
 ; CHECK-SIMPLE: *** IR Pass ModuleToFunctionPassAdaptor on [module] ignored ***
 ; CHECK-SIMPLE: *** IR Dump After VerifierPass on [module] omitted because no change ***

 ; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
 ; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on g filtered out ***
 ; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f ***
 ; CHECK-MULT-PASSES-FILTER-FUNC-NEXT: define i32 @f()
 ; CHECK-MULT-PASSES-FILTER-FUNC: *** IR Dump After InstSimplifyPass on f omitted because no change ***
 
 ; CHECK-SIMPLE-BEFORE: *** IR Dump At Start ***
 ; CHECK-SIMPLE-BEFORE-NEXT: ; ModuleID = {{.+}}
-; CHECK-SIMPLE-BEFORE: *** IR Dump After VerifierPass on [module] omitted because no change ***
 ; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @g()
 ; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass on g ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @g()
 ; CHECK-SIMPLE-BEFORE: *** IR Pass PassManager{{.*}} on g ignored ***
 ; CHECK-SIMPLE-BEFORE: *** IR Dump Before InstSimplifyPass on f ***
 ; CHECK-SIMPLE-BEFORE-NEXT: define i32 @f()
 ; CHECK-SIMPLE-BEFORE: *** IR Dump After InstSimplifyPass on f ***

llvm/test/Other/new-pass-manager-verify-each.ll

 ; RUN: opt -disable-output -debug-pass-manager -verify-each -passes='no-op-module,verify,cgscc(no-op-cgscc,function(no-op-function,loop(no-op-loop)))' %s 2>&1 | FileCheck %s
 
-; Added manually by opt at beginning
-; CHECK: Running pass: VerifierPass
+; opt already manually verifies input IR
+; CHECK-NOT: Running pass: VerifierPass
 
 ; CHECK: Running pass: NoOpModulePass
 ; CHECK: Verifying module
 ; CHECK-NOT: Verifying module
 ; CHECK: Running pass: NoOpCGSCCPass
 ; CHECK: Verifying module
 ; CHECK-NOT: Verifying module
 ; CHECK: Running pass: NoOpFunctionPass

llvm/test/Other/new-pass-manager.ll

 ; RUN:     -passes='function(no-op-function)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
 ; CHECK-FUNCTION-PASS: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
 ; CHECK-FUNCTION-PASS-NEXT: Running analysis: PreservedCFGCheckerAnalysis on foo
 ; CHECK-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
 
 ; RUN: opt -disable-output -debug-pass-manager -passes=print %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MODULE-PRINT
-; CHECK-MODULE-PRINT: Running pass: VerifierPass
 ; CHECK-MODULE-PRINT: Running pass: PrintModulePass
 ; CHECK-MODULE-PRINT: ModuleID
 ; CHECK-MODULE-PRINT: define void @foo(i1 %x, ptr %p1, ptr %p2)
 ; CHECK-MODULE-PRINT: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager -disable-verify -verify-cfg-preserved=1 -passes='print,verify' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-MODULE-VERIFY
 ; CHECK-MODULE-VERIFY: Running pass: PrintModulePass
 ; CHECK-MODULE-VERIFY: ModuleID
 ; CHECK-MODULE-VERIFY: define void @foo(i1 %x, ptr %p1, ptr %p2)
 ; CHECK-MODULE-VERIFY: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager -passes='function(print)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PRINT
-; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
 ; CHECK-FUNCTION-PRINT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
 ; CHECK-FUNCTION-PRINT: Running pass: PrintFunctionPass
 ; CHECK-FUNCTION-PRINT-NOT: ModuleID
 ; CHECK-FUNCTION-PRINT: define void @foo(i1 %x, ptr %p1, ptr %p2)
 ; CHECK-FUNCTION-PRINT: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager -disable-verify -verify-cfg-preserved=1 -passes='function(print,verify)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-VERIFY

 
 ; RUN: opt -disable-output -debug-pass-manager -disable-verify -verify-cfg-preserved=1 -passes='no-op-module,function(no-op-function)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NO-VERIFY
 ; CHECK-NO-VERIFY-NOT: VerifierPass
 ; CHECK-NO-VERIFY: Running pass: NoOpModulePass
 ; CHECK-NO-VERIFY-NOT: VerifierPass
 ; CHECK-NO-VERIFY: Running pass: NoOpFunctionPass
 ; CHECK-NO-VERIFY-NOT: VerifierPass
-; CHECK-NO-VERIFY-NOT: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='require<no-op-module>,cgscc(require<no-op-cgscc>,function(require<no-op-function>))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-ANALYSES
 ; CHECK-ANALYSES: Running pass: RequireAnalysisPass
 ; CHECK-ANALYSES: Running analysis: NoOpModuleAnalysis
 ; CHECK-ANALYSES: Running pass: RequireAnalysisPass
 ; CHECK-ANALYSES: Running analysis: NoOpCGSCCAnalysis

llvm/test/Other/opt-bisect-new-pass-manager.ll

 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-MODULE-PASS
 ; CHECK-LIMIT-MODULE-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on [module]
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-REQUIRED-PASS
-; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
-; CHECK-REQUIRED-PASS: Running pass: VerifierPass
 ; CHECK-REQUIRED-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
-; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
+; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}}VerifierPass
 ; CHECK-REQUIRED-PASS: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LIMIT-REQUIRED-PASS
-; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
-; CHECK-LIMIT-REQUIRED-PASS: Running pass: VerifierPass
 ; CHECK-LIMIT-REQUIRED-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass on [module]
-; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}} VerifierPass
+; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}}VerifierPass
 ; CHECK-LIMIT-REQUIRED-PASS: Running pass: VerifierPass
 
 ; RUN: opt -disable-output -disable-verify \
 ; RUN:     -passes=early-cse -opt-bisect-limit=-1 %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
 ; CHECK-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on f1
 ; CHECK-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on f2
 ; CHECK-FUNCTION-PASS: BISECT: running pass (3) EarlyCSEPass on f3

llvm/test/Other/printer.ll

 ; RUN: opt -passes='mem2reg,instcombine' -print-after-all -disable-output < %s 2>&1 | \
 ; RUN:   FileCheck %s --implicit-check-not='IR Dump'
 define void @tester(){
   ret void
 }
 
 define void @foo(){
   ret void
 }
 
-; CHECK:      *** IR Dump After VerifierPass
 ; CHECK:      *** IR Dump After PromotePass
 ; CHECK-NEXT: define void @tester
 ; CHECK:      *** IR Dump After InstCombinePass
 ; CHECK-NEXT: define void @tester
 ; CHECK:      *** IR Dump After PromotePass
 ; CHECK-NEXT: define void @foo
 ; CHECK:      *** IR Dump After InstCombinePass
 ; CHECK-NEXT: define void @foo
 ; CHECK:      *** IR Dump After VerifierPass

llvm/tools/opt/NewPMDriver.h

 
 namespace opt_tool {
 enum OutputKind {
   OK_NoOutput,
   OK_OutputAssembly,
   OK_OutputBitcode,
   OK_OutputThinLTOBitcode,
 };
-enum VerifierKind {
-  VK_NoVerifier,
-  VK_VerifyInAndOut,
-  VK_VerifyEachPass
-};
+enum VerifierKind { VK_NoVerifier, VK_VerifyOut, VK_VerifyEachPass };
 enum PGOKind {
   NoPGO,
   InstrGen,
   InstrUse,
   SampleUse
 };
 enum CSPGOKind { NoCSPGO, CSInstrGen, CSInstrUse };
 }

llvm/tools/opt/NewPMDriver.cpp

#include "llvm/Support/Extension.def"
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 
   ModulePassManager MPM;
-  if (VK > VK_NoVerifier)
-    MPM.addPass(VerifierPass());
   if (EnableDebugify)
     MPM.addPass(NewPMDebugifyPass());
   if (VerifyDIPreserve)
     MPM.addPass(NewPMDebugifyPass(DebugifyMode::OriginalDebugInfo, "",
                                   &DebugInfoBeforePass));
 
   // Add passes according to the -passes options.
   if (!PassPipeline.empty()) {

llvm/tools/opt/opt.cpp

if (UseNPM) {
     if (OptLevelOz)
       Pipeline = "default<Oz>";
     OutputKind OK = OK_NoOutput;
     if (!NoOutput)
       OK = OutputAssembly
                ? OK_OutputAssembly
                : (OutputThinLTOBC ? OK_OutputThinLTOBitcode : OK_OutputBitcode);
 
-    VerifierKind VK = VK_VerifyInAndOut;
+    VerifierKind VK = VK_VerifyOut;
     if (NoVerify)
       VK = VK_NoVerifier;
     else if (VerifyEach)
       VK = VK_VerifyEachPass;
 
     // The user has asked to use the new pass manager and provided a pipeline
     // string. Hand off the rest of the functionality to the new code for that
     // layer.