[NewPM][optnone] Mark various passes as required

[aeubanks]

Summary

This was done by turning on -enable-npm-optnone and fixing failures.
That will be enabled in a follow-up change for ease of reverting.

[aeubanks]

I think I need a test in clang that tests that no passes are skipped under -O0.

[aeubanks]

Add test

[ychen]

Looks reasonable to me. Please let @asbirlea double-check.

[aeubanks]

Specify target

[aeubanks]

-target -> -triple
rebase

clang/test/CodeGen/O0-no-skipped-passes.c

+// Test that no passes are skipped under -O0/NPM
+//
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fcoroutines-ts 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize=address 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize=hwaddress 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize=memory 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize=thread 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize=local-bounds 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -mllvm -enable-npm-optnone -O0 -fexperimental-new-pass-manager %s -fdebug-pass-manager -emit-llvm -o /dev/null -fsanitize-coverage-trace-pc-guard 2>&1 | FileCheck %s
+
+// CHECK-NOT: Skipping pass
+
+int func(int a) { return a; }

llvm/include/llvm/IR/IRPrintingPasses.h

class PrintModulePass : public PassInfoMixin<PrintModulePass> {
   bool ShouldPreserveUseListOrder;
 
 public:
   PrintModulePass();
   PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
                   bool ShouldPreserveUseListOrder = false);
 
   PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
+  static bool isRequired() { return true; }
 };
 
 /// Pass for printing a Function as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
 class PrintFunctionPass : public PassInfoMixin<PrintFunctionPass> {
   raw_ostream &OS;
   std::string Banner;
 
 public:
   PrintFunctionPass();
   PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");
 
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
+  static bool isRequired() { return true; }
 };
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/IR/PassManager.h

struct RequireAnalysisPass
   /// context requires.
   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
                         ExtraArgTs &&... Args) {
     (void)AM.template getResult<AnalysisT>(Arg,
                                            std::forward<ExtraArgTs>(Args)...);
 
     return PreservedAnalyses::all();
   }
+  static bool isRequired() { return true; }
 };
 
 /// A no-op pass template which simply forces a specific analysis result
 /// to be invalidated.
 template <typename AnalysisT>
 struct InvalidateAnalysisPass
     : PassInfoMixin<InvalidateAnalysisPass<AnalysisT>> {
   /// Run this pass over some unit of IR.

llvm/include/llvm/IR/Verifier.h

 
 public:
   struct Result {
     bool IRBroken, DebugInfoBroken;
   };
 
   Result run(Module &M, ModuleAnalysisManager &);
   Result run(Function &F, FunctionAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 
 /// Check a module for errors, but report debug info errors separately.
 /// Otherwise behaves as the normal verifyModule. Debug info errors can be
 /// "recovered" from by stripping the debug info.
 bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
 
 /// Create a verifier pass.

 class VerifierPass : public PassInfoMixin<VerifierPass> {
   bool FatalErrors;
 
 public:
   explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_VERIFIER_H

llvm/include/llvm/Transforms/Coroutines/CoroCleanup.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Function;
 
 struct CoroCleanupPass : PassInfoMixin<CoroCleanupPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROCLEANUP_H

llvm/include/llvm/Transforms/Coroutines/CoroEarly.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Function;
 
 struct CoroEarlyPass : PassInfoMixin<CoroEarlyPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROEARLY_H

llvm/include/llvm/Transforms/Coroutines/CoroElide.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Function;
 
 struct CoroElidePass : PassInfoMixin<CoroElidePass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROELIDE_H

llvm/include/llvm/Transforms/Coroutines/CoroSplit.h

 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct CoroSplitPass : PassInfoMixin<CoroSplitPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
+  static bool isRequired() { return true; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H

llvm/include/llvm/Transforms/IPO/AlwaysInliner.h

 class AlwaysInlinerPass : public PassInfoMixin<AlwaysInlinerPass> {
   bool InsertLifetime;
 
 public:
   AlwaysInlinerPass(bool InsertLifetime = true)
       : InsertLifetime(InsertLifetime) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 
 /// Create a legacy pass manager instance of a pass to inline and remove
 /// functions marked as "always_inline".
 Pass *createAlwaysInlinerLegacyPass(bool InsertLifetime = true);
 
 }
 
 #endif // LLVM_TRANSFORMS_IPO_ALWAYSINLINER_H

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h

 /// replaces malloc() and free() with custom implementations that allow regions
 /// surrounding requested memory to be checked for invalid accesses.
 class AddressSanitizerPass : public PassInfoMixin<AddressSanitizerPass> {
 public:
   explicit AddressSanitizerPass(bool CompileKernel = false,
                                 bool Recover = false,
                                 bool UseAfterScope = false);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
   bool Recover;
   bool UseAfterScope;
 };
 
 /// Public interface to the address sanitizer module pass for instrumenting code
 /// to check for various memory errors.
 ///
 /// This adds 'asan.module_ctor' to 'llvm.global_ctors'. This pass may also
 /// run intependently of the function address sanitizer.
 class ModuleAddressSanitizerPass
     : public PassInfoMixin<ModuleAddressSanitizerPass> {
 public:
   explicit ModuleAddressSanitizerPass(bool CompileKernel = false,
                                       bool Recover = false,
                                       bool UseGlobalGC = true,
                                       bool UseOdrIndicator = false);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
   bool Recover;
   bool UseGlobalGC;
   bool UseOdrIndicator;
 };
 

llvm/include/llvm/Transforms/Instrumentation/BoundsChecking.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// A pass to instrument code and perform run-time bounds checking on loads,
 /// stores, and other memory intrinsics.
 struct BoundsCheckingPass : PassInfoMixin<BoundsCheckingPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 
 
 /// Legacy pass creation function for the above pass.
 FunctionPass *createBoundsCheckingLegacyPass();
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_BOUNDSCHECKING_H

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

 /// This is a public interface to the hardware address sanitizer pass for
 /// instrumenting code to check for various memory errors at runtime, similar to
 /// AddressSanitizer but based on partial hardware assistance.
 class HWAddressSanitizerPass : public PassInfoMixin<HWAddressSanitizerPass> {
 public:
   explicit HWAddressSanitizerPass(bool CompileKernel = false,
                                   bool Recover = false);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+  static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
   bool Recover;
 };
 
 FunctionPass *createHWAddressSanitizerLegacyPassPass(bool CompileKernel = false,
                                                      bool Recover = false);
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Instrumentation/MemorySanitizer.h

 /// inserts calls to runtime library functions. If the functions aren't declared
 /// yet, the pass inserts the declarations. Otherwise the existing globals are
 /// used.
 struct MemorySanitizerPass : public PassInfoMixin<MemorySanitizerPass> {
   MemorySanitizerPass(MemorySanitizerOptions Options) : Options(Options) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   MemorySanitizerOptions Options;
 };
 }
 
 #endif /* LLVM_TRANSFORMS_INSTRUMENTATION_MEMORYSANITIZER_H */

llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h

explicit ModuleSanitizerCoveragePass(
     if (AllowlistFiles.size() > 0)
       Allowlist = SpecialCaseList::createOrDie(AllowlistFiles,
                                                *vfs::getRealFileSystem());
     if (BlocklistFiles.size() > 0)
       Blocklist = SpecialCaseList::createOrDie(BlocklistFiles,
                                                *vfs::getRealFileSystem());
   }
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 
 private:
   SanitizerCoverageOptions Options;
 
   std::unique_ptr<SpecialCaseList> Allowlist;
   std::unique_ptr<SpecialCaseList> Blocklist;
 };
 

llvm/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h

 /// A function pass for tsan instrumentation.
 ///
 /// Instruments functions to detect race conditions reads. This function pass
 /// inserts calls to runtime library functions. If the functions aren't declared
 /// yet, the pass inserts the declarations. Otherwise the existing globals are
 struct ThreadSanitizerPass : public PassInfoMixin<ThreadSanitizerPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 
 } // namespace llvm
 #endif /* LLVM_TRANSFORMS_INSTRUMENTATION_THREADSANITIZER_H */

llvm/include/llvm/Transforms/Scalar/LowerAtomic.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// A pass that lowers atomic intrinsic into non-atomic intrinsics.
 class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static bool isRequired() { return true; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOWERATOMIC_H

llvm/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h

 #ifndef LLVM_TRANSFORMS_SCALAR_LOWERMATRIXINTRINSICSPASS_H
 #define LLVM_TRANSFORMS_SCALAR_LOWERMATRIXINTRINSICSPASS_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct LowerMatrixIntrinsicsPass : PassInfoMixin<LowerMatrixIntrinsicsPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static bool isRequired() { return true; }
 };
 } // namespace llvm
 
 #endif

llvm/test/Feature/optnone-opt.ll

 ; O2O3-DAG: Skipping pass 'Global Value Numbering'
 ; O2O3-DAG: Skipping pass 'SLP Vectorizer'
 ; NPM-O2O3-DAG: Skipping pass: GVN
 ; NPM-O2O3-DAG: Skipping pass: SLPVectorizerPass
 
 ; Additional IR passes that opt doesn't turn on by default.
 ; MORE-DAG: Skipping pass 'Dead Code Elimination'
 ; MORE-DAG: Skipping pass 'Dead Instruction Elimination'
+; NPM-MORE-DAG: Skipping pass: DCEPass
 ; NPM-MORE-DAG: Skipping pass: GVNHoistPass
-; NPM-MORE-DAG: Skipping pass: LowerAtomicPass
 
 ; Loop IR passes that opt doesn't turn on by default.
 ; LOOP-DAG: Skipping pass 'Delete dead loops'
 ; LOOP-DAG: Skipping pass 'Induction Variable Simplification'
 ; LOOP-DAG: Skipping pass 'Loop Invariant Code Motion'
 ; LOOP-DAG: Skipping pass 'Loop Strength Reduction'
 ; LOOP-DAG: Skipping pass 'Recognize loop idioms'
 ; LOOP-DAG: Skipping pass 'Reroll loops'