[NewPM][CodeGen] Support codegen IR pass testing using opt

[jdoerfert]

This looks reasonable to me. Rubber stamp to unblock it.

llvm/test/CodeGen/X86/unreachableblockelim.ll

 ; RUN: opt -S < %s -unreachableblockelim | FileCheck %s
+; RUN: opt -S < %s -passes='unreachableblockelim' | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @abort()
 
 ; CHECK-LABEL: @foo(
 ; CHECK-NOT: return:

llvm/test/Transforms/PreISelIntrinsicLowering/load-relative.ll

 ; RUN: opt -pre-isel-intrinsic-lowering -S -o - %s | FileCheck %s
+; RUN: opt -passes='pre-isel-intrinsic-lowering' -S < %s | FileCheck %s
 
 ; CHECK: define i8* @foo32(i8* [[P:%.*]], i32 [[O:%.*]])
 define i8* @foo32(i8* %p, i32 %o) {
   ; CHECK: [[OP:%.*]] = getelementptr i8, i8* [[P]], i32 [[O]]
   ; CHECK: [[OPI32:%.*]] = bitcast i8* [[OP]] to i32*
   ; CHECK: [[OI32:%.*]] = load i32, i32* [[OPI32]], align 4
   ; CHECK: [[R:%.*]] = getelementptr i8, i8* [[P]], i32 [[OI32]]
   ; CHECK: ret i8* [[R]]

llvm/test/Transforms/PreISelIntrinsicLowering/objc-arc.ll

 ; RUN: opt -pre-isel-intrinsic-lowering -S -o - %s | FileCheck %s
+; RUN: opt -passes='pre-isel-intrinsic-lowering' -S < %s | FileCheck %s
 
 ; Make sure calls to the objc intrinsics are translated to calls in to the
 ; runtime
 
 define i8* @test_objc_autorelease(i8* %arg0) {
 ; CHECK-LABEL: test_objc_autorelease
 ; CHECK-NEXT: entry
 ; CHECK-NEXT: %0 = notail call i8* @objc_autorelease(i8* %arg0)

llvm/tools/opt/NewPMDriver.h

 /// opt.cpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OPT_NEWPMDRIVER_H
 #define LLVM_TOOLS_OPT_NEWPMDRIVER_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
 
 namespace llvm {
 class StringRef;
 class Module;
 class TargetMachine;
 class ToolOutputFile;
 
 namespace opt_tool {

 ///
 /// This function only exists factored away from opt.cpp in order to prevent
 /// inclusion of the new pass manager headers and the old headers into the same
 /// file. It's interface is consequentially somewhat ad-hoc, but will go away
 /// when the transition finishes.
 ///
 /// ThinLTOLinkOut is only used when OK is OK_OutputThinLTOBitcode, and can be
 /// nullptr.
-bool runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
-                     ToolOutputFile *Out, ToolOutputFile *ThinLinkOut,
-                     ToolOutputFile *OptRemarkFile, StringRef PassPipeline,
-                     ArrayRef<StringRef> PassInfos, opt_tool::OutputKind OK,
-                     opt_tool::VerifierKind VK,
-                     bool ShouldPreserveAssemblyUseListOrder,
-                     bool ShouldPreserveBitcodeUseListOrder,
-                     bool EmitSummaryIndex, bool EmitModuleHash,
-                     bool EnableDebugify, bool Coroutines);
+bool runPassPipeline(
+    StringRef Arg0, Module &M, TargetMachine *TM, ToolOutputFile *Out,
+    ToolOutputFile *ThinLinkOut, ToolOutputFile *OptRemarkFile,
+    StringRef PassPipeline, ArrayRef<StringRef> PassInfos,
+    opt_tool::OutputKind OK, opt_tool::VerifierKind VK,
+    bool ShouldPreserveBitcodeUseListOrder, bool EmitSummaryIndex,
+    bool EmitModuleHash, bool EnableDebugify, bool Coroutines,
+    llvm::function_ref<TargetMachine *(Triple)> GetTargetMachine);
 } // namespace llvm
 
 #endif

llvm/tools/opt/NewPMDriver.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Utils/Debugify.h"
 
 using namespace llvm;
PB.registerOptimizerLastEPCallback(
                                    DebugLogging));
         });
 }
 
 #define HANDLE_EXTENSION(Ext)                                                  \
   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 #include "llvm/Support/Extension.def"
 
-bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
-                           ToolOutputFile *Out, ToolOutputFile *ThinLTOLinkOut,
-                           ToolOutputFile *OptRemarkFile,
-                           StringRef PassPipeline, ArrayRef<StringRef> Passes,
-                           OutputKind OK, VerifierKind VK,
-                           bool ShouldPreserveAssemblyUseListOrder,
-                           bool ShouldPreserveBitcodeUseListOrder,
-                           bool EmitSummaryIndex, bool EmitModuleHash,
-                           bool EnableDebugify, bool Coroutines) {
+bool llvm::runPassPipeline(
+    StringRef Arg0, Module &M, TargetMachine *TM, ToolOutputFile *Out,
+    ToolOutputFile *ThinLTOLinkOut, ToolOutputFile *OptRemarkFile,
+    StringRef PassPipeline, ArrayRef<StringRef> Passes, OutputKind OK,
+    VerifierKind VK, bool ShouldPreserveAssemblyUseListOrder,
+    bool ShouldPreserveBitcodeUseListOrder, bool EmitSummaryIndex,
+    bool EmitModuleHash, bool EnableDebugify, bool Coroutines,
+    llvm::function_ref<TargetMachine *(Triple)> GetTargetMachine) {
   bool VerifyEachPass = VK == VK_VerifyEachPass;
 
   Optional<PGOOptions> P;
   switch (PGOKindFlag) {
   case InstrGen:
     P = PGOOptions(ProfileFile, "", "", PGOOptions::IRInstr);
     break;
   case InstrUse:
PB.registerPipelineParsingCallback(
           MPM.addPass(NewPMDebugifyPass());
           return true;
         } else if (Name == "check-debugify") {
           MPM.addPass(NewPMCheckDebugifyPass());
           return true;
         }
         return false;
       });
+
+  // ASAN
   PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &MPM,
          ArrayRef<PassBuilder::PipelineElement>) {
         if (Name == "asan-pipeline") {
           MPM.addPass(
               RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
           MPM.addPass(
               createModuleToFunctionPassAdaptor(AddressSanitizerPass()));
           MPM.addPass(ModuleAddressSanitizerPass());
           return true;
         } else if (Name == "asan-function-pipeline") {
           MPM.addPass(
               RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
           MPM.addPass(
               createModuleToFunctionPassAdaptor(AddressSanitizerPass()));
           return true;
         }
         return false;
       });
 
+  // Register codegen IR passes. This includs both target-dependent and
+  // target-independent passes.
+
+  // Under new pass manager, target-independent IR passes are exposed through
+  // LLVMTargetMachine. So it must not be null.
+  // FIXME: This could be done earlier in opt.cpp but it means optimization
+  // IR passes would see a default TargetMachine instead of a null one. It
+  // breaks some tests.
+  if (!TM) {
+    std::string TripleStr = M.getTargetTriple();
+    if (TripleStr.empty())
+      TripleStr = sys::getDefaultTargetTriple();
+    TM = GetTargetMachine(Triple(TripleStr));
+  }
+
+  LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM);
+  assert(LLVMTM);
+
+  PB.registerAnalysisRegistrationCallback([LLVMTM](ModuleAnalysisManager &MAM) {
+    LLVMTM->registerModuleAnalyses(MAM);
+  });
+  PB.registerAnalysisRegistrationCallback(
+      [LLVMTM](FunctionAnalysisManager &FAM) {
+        LLVMTM->registerFunctionAnalyses(FAM);
+      });
+  PB.registerAnalysisRegistrationCallback([LLVMTM](LoopAnalysisManager &LAM) {
+    LLVMTM->registerLoopAnalyses(LAM);
+  });
+
+  PB.registerPipelineParsingCallback(
+      [LLVMTM](StringRef Name, ModulePassManager &MPM,
+               ArrayRef<PassBuilder::PipelineElement>) {
+        return LLVMTM->parseModulePass(Name, MPM);
+      });
+  PB.registerPipelineParsingCallback(
+      [LLVMTM](StringRef Name, FunctionPassManager &FPM,
+               ArrayRef<PassBuilder::PipelineElement>) {
+        return LLVMTM->parseFunctionPass(Name, FPM);
+      });
+  PB.registerPipelineParsingCallback(
+      [LLVMTM](StringRef Name, LoopPassManager &LPM,
+               ArrayRef<PassBuilder::PipelineElement>) {
+        return LLVMTM->parseLoopPass(Name, LPM);
+      });
+
 #define HANDLE_EXTENSION(Ext)                                                  \
   get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
 #include "llvm/Support/Extension.def"
 
   // Specially handle the alias analysis manager so that we can register
   // a custom pipeline of AA passes with it.
   AAManager AA;
   if (!AAPipeline.empty()) {

llvm/tools/opt/opt.cpp

if (OptLevelO1)
     return CodeGenOpt::Less;
   if (OptLevelO2)
     return CodeGenOpt::Default;
   if (OptLevelO3)
     return CodeGenOpt::Aggressive;
   return CodeGenOpt::None;
 }
 
-// Returns the TargetMachine instance or zero if no triple is provided.
-static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
-                                       StringRef FeaturesStr,
-                                       const TargetOptions &Options) {
-  std::string Error;
-  const Target *TheTarget =
-      TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
-  // Some modules don't specify a triple, and this is okay.
-  if (!TheTarget) {
-    return nullptr;
-  }
-
-  return TheTarget->createTargetMachine(
-      TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
-      Options, codegen::getExplicitRelocModel(),
-      codegen::getExplicitCodeModel(), GetCodeGenOptLevel());
-}
-
 #ifdef BUILD_EXAMPLES
 void initializeExampleIRTransforms(llvm::PassRegistry &Registry);
 #endif
 
 
 void exportDebugifyStats(llvm::StringRef Path, const DebugifyStatsMap &Map) {
   std::error_code EC;
   raw_fd_ostream OS{Path, EC};
if (!ThinLinkBitcodeFile.empty()) {
           new ToolOutputFile(ThinLinkBitcodeFile, EC, sys::fs::OF_None));
       if (EC) {
         errs() << EC.message() << '\n';
         return 1;
       }
     }
   }
 
+  // Returns the TargetMachine instance or zero if no triple is provided.
+  auto GetTargetMachine = [](Triple TheTriple) -> TargetMachine * {
+    std::string Error;
+    const Target *TheTarget =
+        TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
+    // Some modules don't specify a triple, and this is okay.
+    if (!TheTarget)
+      return nullptr;
+
+    return TheTarget->createTargetMachine(
+        TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
+        codegen::InitTargetOptionsFromCodeGenFlags(),
+        codegen::getExplicitRelocModel(), codegen::getExplicitCodeModel(),
+        GetCodeGenOptLevel());
+  };
+
   Triple ModuleTriple(M->getTargetTriple());
-  std::string CPUStr, FeaturesStr;
   TargetMachine *Machine = nullptr;
-  const TargetOptions Options = codegen::InitTargetOptionsFromCodeGenFlags();
 
   if (ModuleTriple.getArch()) {
-    CPUStr = codegen::getCPUStr();
-    FeaturesStr = codegen::getFeaturesStr();
-    Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
+    Machine = GetTargetMachine(ModuleTriple);
   } else if (ModuleTriple.getArchName() != "unknown" &&
              ModuleTriple.getArchName() != "") {
     errs() << argv[0] << ": unrecognized architecture '"
            << ModuleTriple.getArchName() << "' provided.\n";
     return 1;
   }
 
+  std::string CPUStr = codegen::getCPUStr();
+  std::string FeaturesStr = codegen::getFeaturesStr();
   std::unique_ptr<TargetMachine> TM(Machine);
 
   // Override function attributes based on CPUStr, FeaturesStr, and command line
   // flags.
   codegen::setFunctionAttributes(CPUStr, FeaturesStr, *M);
 
   // If the output is set to be emitted to standard out, and standard out is a
   // console, print out a warning message and refuse to do it.  We don't
if ((EnableNewPassManager && !CodegenPassSpecifiedInPassList()) ||
 
     // 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.
     return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
                            RemarksFile.get(), PassPipeline, Passes, OK, VK,
                            PreserveAssemblyUseListOrder,
                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
-                           EmitModuleHash, EnableDebugify, Coroutines)
+                           EmitModuleHash, EnableDebugify, Coroutines,
+                           GetTargetMachine)
                ? 0
                : 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build. If the -debugify-each option is set, wrap each pass with
   // the (-check)-debugify passes.
   DebugifyCustomPassManager Passes;