diff --git a/llvm/lib/Target/X86/LLVMBuild.txt b/llvm/lib/Target/X86/LLVMBuild.txt
--- a/llvm/lib/Target/X86/LLVMBuild.txt
+++ b/llvm/lib/Target/X86/LLVMBuild.txt
@@ -30,5 +30,5 @@
type = Library
name = X86CodeGen
parent = X86
-required_libraries = Analysis AsmPrinter CodeGen Core MC SelectionDAG Support Target X86Desc X86Info GlobalISel ProfileData CFGuard
+required_libraries = Analysis AsmPrinter CodeGen Core MC Passes SelectionDAG Support Target X86Desc X86Info GlobalISel ProfileData CFGuard
add_to_library_groups = X86
diff --git a/llvm/lib/Target/X86/X86PassRegistry.def b/llvm/lib/Target/X86/X86PassRegistry.def
new file mode 100644
--- /dev/null
+++ b/llvm/lib/Target/X86/X86PassRegistry.def
@@ -0,0 +1,66 @@
+//===- X86PassRegistry.def - Registry of passes for X86 ---------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// X86 pass registry
+//
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+#ifndef FUNCTION_PASS
+#define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+
+#undef FUNCTION_PASS
+
+#ifndef DUMMY_FUNCTION_PASS
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_FUNCTION_PASS("x86-win-eh-state", X86WinEHStatePass, ())
+#undef DUMMY_FUNCTION_PASS
+
+#ifndef MACHINE_FUNCTION_PASS
+#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+
+#undef MACHINE_FUNCTION_PASS
+
+// PASS_NAME is for mocking machine passes, remove it after all machine passes
+// are added new pass manager interface.
+#ifndef DUMMY_MACHINE_FUNCTION_PASS
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR)
+#endif
+DUMMY_MACHINE_FUNCTION_PASS("x86-isel-dag", X86ISelDagPass, (getTM<X86TargetMachine>(), getOptLevel()))
+DUMMY_MACHINE_FUNCTION_PASS("x86-global-basereg", X86GlobalBaseRegPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-condbr-folding", X86CondBrFoldingDummyPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-cmov-converter", X86CmovConverterDummyPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-fixup-setcc", X86FixupSetCCPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-opt-leas", X86OptimizeLEAsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-callframe-opt", X86CallFrameOptimizationPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-avoid-store-foword-block", X86AvoidStoreForwardingBlocksPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-speculative-load-hardening", X86SpeculativeLoadHardeningPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-flags-copy-lowering", X86FlagsCopyLoweringDummyPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-win-alloc-expander", X86WinAllocaExpanderPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-domain-reassign", X86DomainReassignmentPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-fp-stackifier", X86FloatingPointStackifierPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-expand-pseudo", X86ExpandPseudoPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-exec-domain-fix", X86ExecutionDomainFixPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-indirectbr-tracking", X86IndirectBranchTrackingPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-issue-vzero-upper", X86IssueVZeroUpperPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-fixup-bwinsts", X86FixupBWInstsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-pad-short-funcs", X86PadShortFunctionsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-fixup-leas", X86FixupLEAsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-evex-to-vex-insts", X86EvexToVexInstsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-discriminate-memops", X86DiscriminateMemOpsPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-insert-prefetch", X86InsertPrefetchPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-insert-x87-wait", X86InsertX87waitPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-retpoline-thunks", X86RetpolineThunksPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-avoid-trailing-call", X86AvoidTrailingCallPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("x86-asm-printer", X86AsmPrinterPass, ())
+DUMMY_MACHINE_FUNCTION_PASS("cleanup-local-dyn-tls", CleanupLocalDynamicTLSPass, ())
+#undef DUMMY_MACHINE_FUNCTION_PASS
\ No newline at end of file
diff --git a/llvm/lib/Target/X86/X86TargetMachine.h b/llvm/lib/Target/X86/X86TargetMachine.h
--- a/llvm/lib/Target/X86/X86TargetMachine.h
+++ b/llvm/lib/Target/X86/X86TargetMachine.h
@@ -49,6 +49,24 @@
// Set up the pass pipeline.
TargetPassConfig *createPassConfig(PassManagerBase &PM) override;
+ Expected<std::pair<ModulePassManager, MachineFunctionPassManager>>
+ buildCodeGenPipeline(raw_pwrite_stream &, raw_pwrite_stream *,
+ CodeGenFileType, CGPassBuilderOption,
+ MachineFunctionAnalysisManager &,
+ PassInstrumentationCallbacks *) override;
+
+ Expected<ModulePassManager>
+ parseIRPipeline(StringRef, CGPassBuilderOption,
+ MachineFunctionAnalysisManager &,
+ PassInstrumentationCallbacks *) override;
+
+ Expected<MachineFunctionPassManager>
+ parseMIRPipeline(StringRef, CGPassBuilderOption,
+ MachineFunctionAnalysisManager &,
+ PassInstrumentationCallbacks *) override;
+
+ bool isMachinePass(StringRef Name) const override;
+
TargetLoweringObjectFile *getObjFileLowering() const override {
return TLOF.get();
}
diff --git a/llvm/lib/Target/X86/X86TargetMachine.cpp b/llvm/lib/Target/X86/X86TargetMachine.cpp
--- a/llvm/lib/Target/X86/X86TargetMachine.cpp
+++ b/llvm/lib/Target/X86/X86TargetMachine.cpp
@@ -26,6 +26,7 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/CodeGen/CodeGenPassBuilder.h"
#include "llvm/CodeGen/ExecutionDomainFix.h"
#include "llvm/CodeGen/GlobalISel/CallLowering.h"
#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
@@ -555,3 +556,281 @@
std::unique_ptr<CSEConfigBase> X86PassConfig::getCSEConfig() const {
return getStandardCSEConfigForOpt(TM->getOptLevel());
}
+
+namespace {
+
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
+ template <typename... Ts> PASS_NAME(Ts &&...) {} \
+ PreservedAnalyses run(Function &, FunctionAnalysisManager &) { \
+ return PreservedAnalyses::all(); \
+ } \
+ };
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ struct PASS_NAME : public PassInfoMixin<PASS_NAME> { \
+ template <typename... Ts> PASS_NAME(Ts &&...) {} \
+ PreservedAnalyses run(MachineFunction &, \
+ MachineFunctionAnalysisManager &) { \
+ return PreservedAnalyses::all(); \
+ } \
+ static AnalysisKey Key; \
+ }; \
+ AnalysisKey PASS_NAME::Key;
+#include "X86PassRegistry.def"
+
+/// X86 Code Generator Pass Configuration Options.
+class X86CodeGenPassBuilder : public CodeGenPassBuilder<X86CodeGenPassBuilder> {
+public:
+ X86CodeGenPassBuilder(X86TargetMachine &TM, CGPassBuilderOption Opt,
+ PassInstrumentationCallbacks *PIC)
+ : CodeGenPassBuilder<X86CodeGenPassBuilder>(TM, Opt, PIC) {
+ // Target-specific `CGPassBuilderOption` could be overridden here.
+ }
+
+ Error addTargetPass(AddIRPass &, StringRef) const;
+ Error addTargetPass(AddMachinePass &, StringRef) const;
+ void addIRPasses(AddIRPass &) const;
+ void addPreISel(AddIRPass &) const;
+ Error addInstSelector(AddMachinePass &) const;
+ Error addIRTranslator(AddMachinePass &) const;
+ Error addLegalizeMachineIR(AddMachinePass &) const;
+ Error addRegBankSelect(AddMachinePass &) const;
+ Error addGlobalInstructionSelect(AddMachinePass &) const;
+ void addILPOpts(AddMachinePass &) const;
+ void addMachineSSAOptimization(AddMachinePass &) const;
+ void addPreRegAlloc(AddMachinePass &) const;
+ void addPostRegAlloc(AddMachinePass &) const;
+ void addPreEmitPass(AddMachinePass &) const;
+ void addPreEmitPass2(AddMachinePass &) const;
+ void addPreSched2(AddMachinePass &) const;
+ void addAsmPrinter(AddMachinePass &, CreateMCStreamer) const;
+};
+
+} // namespace
+
+Error X86CodeGenPassBuilder::addTargetPass(AddIRPass &addPass,
+ StringRef Name) const {
+#define FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) { \
+ addPass(PASS_NAME CONSTRUCTOR); \
+ return Error::success(); \
+ }
+#define DUMMY_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) { \
+ addPass(PASS_NAME CONSTRUCTOR); \
+ return Error::success(); \
+ }
+#include "X86PassRegistry.def"
+
+ return Error::success();
+}
+
+Error X86CodeGenPassBuilder::addTargetPass(AddMachinePass &addPass,
+ StringRef Name) const {
+#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) { \
+ addPass(PASS_NAME CONSTRUCTOR); \
+ return Error::success(); \
+ }
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) { \
+ addPass(PASS_NAME CONSTRUCTOR); \
+ return Error::success(); \
+ }
+#include "X86PassRegistry.def"
+
+ return Error::success();
+}
+
+void X86CodeGenPassBuilder::addIRPasses(AddIRPass &addPass) const {
+ addPass(AtomicExpandPass());
+
+ CodeGenPassBuilder::addIRPasses(addPass);
+
+ if (TM.getOptLevel() != CodeGenOpt::None)
+ addPass(InterleavedAccessPass());
+
+ // Add passes that handle indirect branch removal and insertion of a retpoline
+ // thunk. These will be a no-op unless a function subtarget has the retpoline
+ // feature enabled.
+ addPass(IndirectBrExpandPass());
+
+ // Add Control Flow Guard checks.
+ const Triple &TT = TM.getTargetTriple();
+ if (TT.isOSWindows()) {
+ if (TT.getArch() == Triple::x86_64) {
+ addPass(CFGuardDispatchPass());
+ } else {
+ addPass(CFGuardCheckPass());
+ }
+ }
+}
+
+Error X86CodeGenPassBuilder::addInstSelector(AddMachinePass &addPass) const {
+ // Install an instruction selector.
+ addPass(X86ISelDagPass(getTM<X86TargetMachine>(), getOptLevel()));
+
+ // For ELF, cleanup any local-dynamic TLS accesses.
+ if (TM.getTargetTriple().isOSBinFormatELF() &&
+ TM.getOptLevel() != CodeGenOpt::None)
+ addPass(CleanupLocalDynamicTLSPass());
+
+ addPass(X86GlobalBaseRegPass());
+ return Error::success();
+}
+
+Error X86CodeGenPassBuilder::addIRTranslator(AddMachinePass &addPass) const {
+ addPass(IRTranslatorPass());
+ return Error::success();
+}
+
+Error X86CodeGenPassBuilder::addLegalizeMachineIR(
+ AddMachinePass &addPass) const {
+ addPass(LegalizerPass());
+ return Error::success();
+}
+
+Error X86CodeGenPassBuilder::addRegBankSelect(AddMachinePass &addPass) const {
+ addPass(RegBankSelectPass());
+ return Error::success();
+}
+
+Error X86CodeGenPassBuilder::addGlobalInstructionSelect(
+ AddMachinePass &addPass) const {
+ addPass(InstructionSelectPass());
+ return Error::success();
+}
+
+void X86CodeGenPassBuilder::addILPOpts(AddMachinePass &addPass) const {
+ if (EnableCondBrFoldingPass)
+ addPass(X86CondBrFoldingDummyPass()); // TODO
+ addPass(EarlyIfConverterPass());
+ if (EnableMachineCombinerPass)
+ addPass(MachineCombinerPass());
+ addPass(X86CmovConverterDummyPass()); // TODO
+}
+
+void X86CodeGenPassBuilder::addPreISel(AddIRPass &addPass) const {
+ // Only add this pass for 32-bit x86 Windows.
+ const Triple &TT = TM.getTargetTriple();
+ if (TT.isOSWindows() && TT.getArch() == Triple::x86)
+ addPass(X86WinEHStatePass());
+}
+
+void X86CodeGenPassBuilder::addPreRegAlloc(AddMachinePass &addPass) const {
+ if (TM.getOptLevel() != CodeGenOpt::None) {
+ addPass(LiveRangeShrinkPass());
+ addPass(X86FixupSetCCPass());
+ addPass(X86OptimizeLEAsPass());
+ addPass(X86CallFrameOptimizationPass());
+ addPass(X86AvoidStoreForwardingBlocksPass());
+ }
+
+ addPass(X86SpeculativeLoadHardeningPass());
+ addPass(X86FlagsCopyLoweringDummyPass()); // TODO: port to NPM and rename
+ addPass(X86WinAllocaExpanderPass());
+}
+
+void X86CodeGenPassBuilder::addMachineSSAOptimization(
+ AddMachinePass &addPass) const {
+ addPass(X86DomainReassignmentPass());
+ CodeGenPassBuilder::addMachineSSAOptimization(addPass);
+}
+
+void X86CodeGenPassBuilder::addPostRegAlloc(AddMachinePass &addPass) const {
+ addPass(X86FloatingPointStackifierPass());
+}
+
+void X86CodeGenPassBuilder::addPreSched2(AddMachinePass &addPass) const {
+ addPass(X86ExpandPseudoPass());
+}
+
+void X86CodeGenPassBuilder::addPreEmitPass(AddMachinePass &addPass) const {
+ if (getOptLevel() != CodeGenOpt::None) {
+ addPass(X86ExecutionDomainFixPass());
+ addPass(BreakFalseDepsPass());
+ }
+
+ addPass(X86IndirectBranchTrackingPass());
+
+ addPass(X86IssueVZeroUpperPass());
+
+ if (getOptLevel() != CodeGenOpt::None) {
+ addPass(X86FixupBWInstsPass());
+ addPass(X86PadShortFunctionsPass());
+ addPass(X86FixupLEAsPass());
+ }
+ addPass(X86EvexToVexInstsPass());
+ addPass(X86DiscriminateMemOpsPass());
+ addPass(X86InsertPrefetchPass());
+ addPass(X86InsertX87waitPass());
+}
+
+void X86CodeGenPassBuilder::addPreEmitPass2(AddMachinePass &addPass) const {
+ const Triple &TT = TM.getTargetTriple();
+ const MCAsmInfo *MAI = TM.getMCAsmInfo();
+
+ addPass(X86RetpolineThunksPass());
+
+ // Insert extra int3 instructions after trailing call instructions to avoid
+ // issues in the unwinder.
+ if (TT.isOSWindows() && TT.getArch() == Triple::x86_64)
+ addPass(X86AvoidTrailingCallPass());
+
+ // Verify basic block incoming and outgoing cfa offset and register values and
+ // correct CFA calculation rule where needed by inserting appropriate CFI
+ // instructions.
+ if (!TT.isOSDarwin() &&
+ (!TT.isOSWindows() ||
+ MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI))
+ addPass(CFIInstrInserterPass());
+ // Identify valid longjmp targets for Windows Control Flow Guard.
+ if (TT.isOSWindows())
+ addPass(CFGuardLongjmpPass());
+}
+
+void X86CodeGenPassBuilder::addAsmPrinter(AddMachinePass &addPass,
+ CreateMCStreamer callback) const {
+ addPass(X86AsmPrinterPass(callback));
+}
+
+Expected<std::pair<ModulePassManager, MachineFunctionPassManager>>
+X86TargetMachine::buildCodeGenPipeline(raw_pwrite_stream &Out,
+ raw_pwrite_stream *DwoOut,
+ CodeGenFileType FileType,
+ CGPassBuilderOption Opts,
+ MachineFunctionAnalysisManager &MFAM,
+ PassInstrumentationCallbacks *PIC) {
+ X86CodeGenPassBuilder X86CGPB{*this, Opts, PIC};
+ X86CGPB.registerAnalyses(MFAM);
+ return X86CGPB.buildPipeline(Out, DwoOut, FileType);
+}
+
+Expected<ModulePassManager> X86TargetMachine::parseIRPipeline(
+ StringRef PipelineText, CGPassBuilderOption Opts,
+ MachineFunctionAnalysisManager &MFAM, PassInstrumentationCallbacks *PIC) {
+ X86CodeGenPassBuilder X86CGPB{*this, Opts, PIC};
+ X86CGPB.registerAnalyses(MFAM);
+ return X86CGPB.parseIRPipeline(PipelineText);
+}
+
+Expected<MachineFunctionPassManager> X86TargetMachine::parseMIRPipeline(
+ StringRef PipelineText, CGPassBuilderOption Opts,
+ MachineFunctionAnalysisManager &MFAM, PassInstrumentationCallbacks *PIC) {
+ X86CodeGenPassBuilder X86CGPB{*this, Opts, PIC};
+ X86CGPB.registerAnalyses(MFAM);
+ return X86CGPB.parseMIRPipeline(PipelineText);
+}
+
+bool X86TargetMachine::isMachinePass(StringRef Name) const {
+#define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) \
+ return true;
+#define DUMMY_MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
+ if (Name == NAME) \
+ return true;
+#include "X86PassRegistry.def"
+#include "llvm/CodeGen/MachinePassRegistry.def"
+
+ return false;
+}
diff --git a/llvm/test/CodeGen/Generic/llc-start-stop-instance-errors.ll b/llvm/test/CodeGen/Generic/llc-start-stop-instance-errors.ll
--- a/llvm/test/CodeGen/Generic/llc-start-stop-instance-errors.ll
+++ b/llvm/test/CodeGen/Generic/llc-start-stop-instance-errors.ll
@@ -1,4 +1,6 @@
; RUN: not --crash llc -debug-pass=Structure -stop-after=dead-mi-elimination,arst %s -o /dev/null 2>&1 \
; RUN: | FileCheck -check-prefix=NOT-NUM %s
+; RUN: not --crash llc -enable-new-pm -debug-pass-manager -stop-after=dead-mi-elimination,arst %s -o /dev/null 2>&1 \
+; RUN: | FileCheck -check-prefix=NOT-NUM %s
; NOT-NUM: LLVM ERROR: invalid pass instance specifier dead-mi-elimination,arst
diff --git a/llvm/test/CodeGen/Generic/new-pm/llc-start-stop.ll b/llvm/test/CodeGen/Generic/new-pm/llc-start-stop.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/CodeGen/Generic/new-pm/llc-start-stop.ll
@@ -0,0 +1,48 @@
+; RUN: llc < %s -enable-new-pm -debug-pass-manager -stop-after=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=STOP-AFTER
+; STOP-AFTER: Running pass: AtomicExpandPass
+; STOP-AFTER-NEXT: Running pass: VerifierPass
+; STOP-AFTER-NOT: Running pass:
+
+; RUN: llc < %s -enable-new-pm -debug-pass-manager -stop-before=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=STOP-BEFORE
+; STOP-BEFORE: Running pass: AtomicExpandPass
+; STOP-BEFORE-NOT: Running pass:
+
+; RUN: llc < %s -enable-new-pm -debug-pass-manager -start-after=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=START-AFTER
+; START-AFTER: Running pass: ModuleToFunctionPassAdaptor
+; START-AFTER: Starting llvm::Function pass manager run
+; START-AFTER-NOT: Running pass:
+; START-AFTER: Running pass: {{.*}}LoopStrengthReducePass
+
+; RUN: llc < %s -enable-new-pm -debug-pass-manager -start-before=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=START-BEFORE
+; START-BEFORE: Running pass: ModuleToFunctionPassAdaptor
+; START-BEFORE: Starting llvm::Function pass manager run
+; START-BEFORE-NOT: Running pass:
+; START-BEFORE: Running pass: VerifierPass
+
+; RUN: not --crash llc < %s -enable-new-pm -start-before=nonexistent -o /dev/null 2>&1 \
+; RUN: | FileCheck %s -check-prefix=NONEXISTENT-START-BEFORE
+; RUN: not --crash llc < %s -enable-new-pm -stop-before=nonexistent -o /dev/null 2>&1 \
+; RUN: | FileCheck %s -check-prefix=NONEXISTENT-STOP-BEFORE
+; RUN: not --crash llc < %s -enable-new-pm -start-after=nonexistent -o /dev/null 2>&1 \
+; RUN: | FileCheck %s -check-prefix=NONEXISTENT-START-AFTER
+; RUN: not --crash llc < %s -enable-new-pm -stop-after=nonexistent -o /dev/null 2>&1 \
+; RUN: | FileCheck %s -check-prefix=NONEXISTENT-STOP-AFTER
+; NONEXISTENT-START-BEFORE: "nonexistent" pass could not be found.
+; NONEXISTENT-STOP-BEFORE: "nonexistent" pass could not be found.
+; NONEXISTENT-START-AFTER: "nonexistent" pass could not be found.
+; NONEXISTENT-STOP-AFTER: "nonexistent" pass could not be found.
+
+; RUN: not --crash llc < %s -enable-new-pm -start-before=verify -start-after=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=DOUBLE-START
+; RUN: not --crash llc < %s -enable-new-pm -stop-before=verify -stop-after=verify \
+; RUN: -o /dev/null 2>&1 | FileCheck %s -check-prefix=DOUBLE-STOP
+; DOUBLE-START: start-before and start-after specified!
+; DOUBLE-STOP: stop-before and stop-after specified!
+
+define void @f() {
+ ret void
+}
diff --git a/llvm/test/CodeGen/X86/new-pm/O0-pipeline.ll b/llvm/test/CodeGen/X86/new-pm/O0-pipeline.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/CodeGen/X86/new-pm/O0-pipeline.ll
@@ -0,0 +1,73 @@
+; When EXPENSIVE_CHECKS are enabled, the machine verifier appears between each
+; pass. Ignore it with 'grep -v'.
+; RUN: llc -mtriple=x86_64-- -O0 -debug-pass-manager -enable-new-pm < %s \
+; RUN: -o /dev/null 2>&1 | grep -v 'Verify generated machine code' | FileCheck %s
+
+; REQUIRES: asserts
+
+; CHECK-LABEL: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Starting llvm::Module pass manager run.
+; CHECK-NEXT: Running pass: PreISelIntrinsicLoweringPass
+; CHECK-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
+; CHECK-NEXT: Running analysis: InnerAnalysisManagerProxy
+; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Starting llvm::Function pass manager run.
+; CHECK-NEXT: Running pass: AtomicExpandPass
+; CHECK-NEXT: Running pass: VerifierPass
+; CHECK-NEXT: Running analysis: VerifierAnalysis
+; CHECK-NEXT: Running pass: GCLoweringPass
+; CHECK-NEXT: Running pass: ShadowStackGCLoweringPass
+; CHECK-NEXT: Running pass: LowerConstantIntrinsicsPass
+; CHECK-NEXT: Running pass: UnreachableBlockElimPass
+; CHECK-NEXT: Running pass: EntryExitInstrumenterPass
+; CHECK-NEXT: Invalidating all non-preserved analyses for:
+; CHECK-NEXT: Invalidating analysis: VerifierAnalysis
+; CHECK-NEXT: Running pass: ScalarizeMaskedMemIntrinPass
+; CHECK-NEXT: Running pass: ExpandReductionsPass
+; CHECK-NEXT: Running analysis: TargetIRAnalysis
+; CHECK-NEXT: Running pass: IndirectBrExpandPass
+; CHECK-NEXT: Running pass: DwarfEHPass
+; CHECK-NEXT: Running pass: SafeStackPass
+; CHECK-NEXT: Running pass: StackProtectorPass
+; CHECK-NEXT: Running pass: VerifierPass
+; CHECK-NEXT: Running analysis: VerifierAnalysis
+; CHECK-NEXT: Finished llvm::Function pass manager run.
+; CHECK-NEXT: Invalidating all non-preserved analyses for:
+; CHECK-NEXT: Finished llvm::Module pass manager run.
+; CHECK-NEXT: Running analysis: MachineModuleAnalysis
+; CHECK-NEXT: Starting llvm::MachineFunction pass manager run.
+; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Running pass: {{.*}}X86ISelDagPass
+; CHECK-NEXT: Running pass: {{.*}}X86GlobalBaseRegPass
+; CHECK-NEXT: Running pass: FinalizeISelPass
+; CHECK-NEXT: Running pass: LocalStackSlotPass
+; CHECK-NEXT: Running pass: {{.*}}X86SpeculativeLoadHardeningPass
+; CHECK-NEXT: Running pass: {{.*}}X86FlagsCopyLoweringDummyPass
+; CHECK-NEXT: Running pass: {{.*}}X86WinAllocaExpanderPass
+; CHECK-NEXT: Running pass: PHIEliminationPass
+; CHECK-NEXT: Running pass: TwoAddressInstructionPass
+; CHECK-NEXT: Running pass: RAFastPass
+; CHECK-NEXT: Running pass: {{.*}}X86FloatingPointStackifierPass
+; CHECK-NEXT: Running pass: PrologEpilogInserterPass
+; CHECK-NEXT: Running pass: ExpandPostRAPseudosPass
+; CHECK-NEXT: Running pass: {{.*}}X86ExpandPseudoPass
+; CHECK-NEXT: Running pass: FEntryInserterPass
+; CHECK-NEXT: Running pass: XRayInstrumentationPass
+; CHECK-NEXT: Running pass: PatchableFunctionPass
+; CHECK-NEXT: Running pass: {{.*}}X86IndirectBranchTrackingPass
+; CHECK-NEXT: Running pass: {{.*}}X86IssueVZeroUpperPass
+; CHECK-NEXT: Running pass: {{.*}}X86EvexToVexInstsPass
+; CHECK-NEXT: Running pass: {{.*}}X86DiscriminateMemOpsPass
+; CHECK-NEXT: Running pass: {{.*}}X86InsertPrefetchPass
+; CHECK-NEXT: Running pass: {{.*}}X86InsertX87waitPass
+; CHECK-NEXT: Running pass: FuncletLayoutPass
+; CHECK-NEXT: Running pass: StackMapLivenessPass
+; CHECK-NEXT: Running pass: LiveDebugValuesPass
+; CHECK-NEXT: Running pass: {{.*}}X86RetpolineThunksPass
+; CHECK-NEXT: Running pass: CFIInstrInserterPass
+; CHECK-NEXT: Running pass: {{.*}}X86AsmPrinterPass
+; CHECK-NEXT: Finished llvm::MachineFunction pass manager run.
+
+define void @f() {
+ ret void
+}
diff --git a/llvm/test/CodeGen/X86/new-pm/llc-start-stop-instance.ll b/llvm/test/CodeGen/X86/new-pm/llc-start-stop-instance.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/CodeGen/X86/new-pm/llc-start-stop-instance.ll
@@ -0,0 +1,35 @@
+; RUN: llc -mtriple=x86_64-- -enable-new-pm -debug-pass-manager -stop-after=verify,1 \
+; RUN: %s -o /dev/null 2>&1 | FileCheck -check-prefix=STOP-AFTER-1 %s
+
+; RUN: llc -mtriple=x86_64-- -enable-new-pm -debug-pass-manager -stop-after=verify,0 \
+; RUN: %s -o /dev/null 2>&1 | FileCheck -check-prefix=STOP-AFTER-0 %s
+
+; RUN: llc -mtriple=x86_64-- -enable-new-pm -debug-pass-manager -stop-before=verify,1 \
+; RUN: %s -o /dev/null 2>&1 | FileCheck -check-prefix=STOP-BEFORE-1 %s
+
+; RUN: llc -mtriple=x86_64-- -enable-new-pm -debug-pass-manager -start-before=verify,1 \
+; RUN: %s -o /dev/null 2>&1 | FileCheck -check-prefix=START-BEFORE-1 %s
+
+; RUN: llc -mtriple=x86_64-- -enable-new-pm -debug-pass-manager -start-after=verify,1 \
+; RUN: %s -o /dev/null 2>&1 | FileCheck -check-prefix=START-AFTER-1 %s
+
+
+; STOP-AFTER-1: Running pass: VerifierPass
+; STOP-AFTER-1: Running pass: VerifierPass
+
+; STOP-AFTER-0-NOT: Running pass: VerifierPass
+; STOP-AFTER-0: Running pass: VerifierPass
+; STOP-AFTER-0-NOT: Running pass: VerifierPass
+
+; STOP-BEFORE-1: Running pass: VerifierPass
+; STOP-BEFORE-1-NOT: Running pass: VerifierPass
+
+; START-BEFORE-1-NOT: Running pass: VerifierPass
+; START-BEFORE-1: Running pass: VerifierPass
+; START-BEFORE-1-NOT: Running pass: VerifierPass
+
+; START-AFTER-1-NOT: Running pass: VerifierPass
+
+define void @f() {
+ ret void
+}
diff --git a/llvm/test/CodeGen/X86/new-pm/opt-pipeline.ll b/llvm/test/CodeGen/X86/new-pm/opt-pipeline.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/CodeGen/X86/new-pm/opt-pipeline.ll
@@ -0,0 +1,135 @@
+; When EXPENSIVE_CHECKS are enabled, the machine verifier appears between each
+; pass. Ignore it with 'grep -v'.
+; RUN: llc -mtriple=x86_64-- -O1 -debug-pass-manager -enable-new-pm < %s \
+; RUN: -o /dev/null 2>&1 | FileCheck %s
+; RUN: llc -mtriple=x86_64-- -O2 -debug-pass-manager -enable-new-pm < %s \
+; RUN: -o /dev/null 2>&1 | FileCheck %s
+; RUN: llc -mtriple=x86_64-- -O3 -debug-pass-manager -enable-new-pm < %s \
+; RUN: -o /dev/null 2>&1 | FileCheck %s
+
+; REQUIRES: asserts
+
+; CHECK-LABEL: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Starting llvm::Module pass manager run.
+; CHECK-NEXT: Running pass: PreISelIntrinsicLoweringPass
+; CHECK-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
+; CHECK-NEXT: Running analysis: InnerAnalysisManagerProxy
+; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Starting llvm::Function pass manager run.
+; CHECK-NEXT: Running pass: AtomicExpandPass
+; CHECK-NEXT: Running pass: VerifierPass
+; CHECK-NEXT: Running analysis: VerifierAnalysis
+; CHECK-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStrengthReducePass{{.*}}>
+; CHECK-NEXT: Starting llvm::Function pass manager run.
+; CHECK-NEXT: Running pass: LoopSimplifyPass
+; CHECK-NEXT: Running analysis: LoopAnalysis
+; CHECK-NEXT: Running analysis: DominatorTreeAnalysis
+; CHECK-NEXT: Running analysis: AssumptionAnalysis
+; CHECK-NEXT: Running pass: LCSSAPass
+; CHECK-NEXT: Finished llvm::Function pass manager run.
+; CHECK-NEXT: Running pass: MergeICmpsPass
+; CHECK-NEXT: Running analysis: TargetLibraryAnalysis
+; CHECK-NEXT: Running analysis: TargetIRAnalysis
+; CHECK-NEXT: Running analysis: AAManager
+; CHECK-NEXT: Running pass: ExpandMemCmpPass
+; CHECK-NEXT: Running pass: GCLoweringPass
+; CHECK-NEXT: Running pass: ShadowStackGCLoweringPass
+; CHECK-NEXT: Running pass: LowerConstantIntrinsicsPass
+; CHECK-NEXT: Running pass: UnreachableBlockElimPass
+; CHECK-NEXT: Running pass: ConstantHoistingPass
+; CHECK-NEXT: Running analysis: BlockFrequencyAnalysis
+; CHECK-NEXT: Running analysis: BranchProbabilityAnalysis
+; CHECK-NEXT: Running analysis: PostDominatorTreeAnalysis
+; CHECK-NEXT: Running analysis: OuterAnalysisManagerProxy
+; CHECK-NEXT: Running pass: PartiallyInlineLibCallsPass
+; CHECK-NEXT: Running pass: EntryExitInstrumenterPass
+; CHECK-NEXT: Invalidating all non-preserved analyses for:
+; CHECK-NEXT: Invalidating analysis: VerifierAnalysis
+; CHECK-NEXT: Running pass: ScalarizeMaskedMemIntrinPass
+; CHECK-NEXT: Running pass: ExpandReductionsPass
+; CHECK-NEXT: Running pass: InterleavedAccessPass
+; CHECK-NEXT: Running pass: IndirectBrExpandPass
+; CHECK-NEXT: Running pass: CodeGenPreparePass
+; CHECK-NEXT: Running pass: DwarfEHPass
+; CHECK-NEXT: Running pass: SafeStackPass
+; CHECK-NEXT: Running pass: StackProtectorPass
+; CHECK-NEXT: Running pass: VerifierPass
+; CHECK-NEXT: Running analysis: VerifierAnalysis
+; CHECK-NEXT: Finished llvm::Function pass manager run.
+; CHECK-NEXT: Invalidating all non-preserved analyses for:
+; CHECK-NEXT: Finished llvm::Module pass manager run.
+; CHECK-NEXT: Running analysis: MachineModuleAnalysis
+; CHECK-NEXT: Starting llvm::MachineFunction pass manager run.
+; CHECK-NEXT: Running analysis: PassInstrumentationAnalysis
+; CHECK-NEXT: Running pass: {{.*}}X86ISelDagPass
+; CHECK-NEXT: Running pass: {{.*}}CleanupLocalDynamicTLSPass
+; CHECK-NEXT: Running pass: {{.*}}X86GlobalBaseRegPass
+; CHECK-NEXT: Running pass: FinalizeISelPass
+; CHECK-NEXT: Running pass: {{.*}}X86DomainReassignmentPass
+; CHECK-NEXT: Running pass: EarlyTailDuplicatePass
+; CHECK-NEXT: Running pass: OptimizePHIsPass
+; CHECK-NEXT: Running pass: StackColoringPass
+; CHECK-NEXT: Running pass: LocalStackSlotPass
+; CHECK-NEXT: Running pass: DeadMachineInstructionElimPass
+; CHECK-NEXT: Running pass: EarlyIfConverterPass
+; CHECK-NEXT: Running pass: MachineCombinerPass
+; CHECK-NEXT: Running pass: {{.*}}X86CmovConverterDummyPass
+; CHECK-NEXT: Running pass: EarlyMachineLICMPass
+; CHECK-NEXT: Running pass: MachineCSEPass
+; CHECK-NEXT: Running pass: MachineSinkingPass
+; CHECK-NEXT: Running pass: PeepholeOptimizerPass
+; CHECK-NEXT: Running pass: DeadMachineInstructionElimPass
+; CHECK-NEXT: Running pass: LiveRangeShrinkPass
+; CHECK-NEXT: Running pass: {{.*}}X86FixupSetCCPass
+; CHECK-NEXT: Running pass: {{.*}}X86OptimizeLEAsPass
+; CHECK-NEXT: Running pass: {{.*}}X86CallFrameOptimizationPass
+; CHECK-NEXT: Running pass: {{.*}}X86AvoidStoreForwardingBlocksPass
+; CHECK-NEXT: Running pass: {{.*}}X86SpeculativeLoadHardeningPass
+; CHECK-NEXT: Running pass: {{.*}}X86FlagsCopyLoweringDummyPass
+; CHECK-NEXT: Running pass: {{.*}}X86WinAllocaExpanderPass
+; CHECK-NEXT: Running pass: DetectDeadLanesPass
+; CHECK-NEXT: Running pass: ProcessImplicitDefsPass
+; CHECK-NEXT: Running pass: PHIEliminationPass
+; CHECK-NEXT: Running pass: TwoAddressInstructionPass
+; CHECK-NEXT: Running pass: RegisterCoalescerPass
+; CHECK-NEXT: Running pass: RenameIndependentSubregsPass
+; CHECK-NEXT: Running pass: MachineSchedulerPass
+; CHECK-NEXT: Running pass: RAGreedyPass
+; CHECK-NEXT: Running pass: VirtRegRewriterPass
+; CHECK-NEXT: Running pass: StackSlotColoringPass
+; CHECK-NEXT: Running pass: {{.*}}X86FloatingPointStackifierPass
+; CHECK-NEXT: Running pass: PostRAMachineSinkingPass
+; CHECK-NEXT: Running pass: ShrinkWrapPass
+; CHECK-NEXT: Running pass: PrologEpilogInserterPass
+; CHECK-NEXT: Running pass: BranchFolderPass
+; CHECK-NEXT: Running pass: TailDuplicatePass
+; CHECK-NEXT: Running pass: MachineCopyPropagationPass
+; CHECK-NEXT: Running pass: ExpandPostRAPseudosPass
+; CHECK-NEXT: Running pass: {{.*}}X86ExpandPseudoPass
+; CHECK-NEXT: Running pass: PostRASchedulerPass
+; CHECK-NEXT: Running pass: MachineBlockPlacementPass
+; CHECK-NEXT: Running pass: FEntryInserterPass
+; CHECK-NEXT: Running pass: XRayInstrumentationPass
+; CHECK-NEXT: Running pass: PatchableFunctionPass
+; CHECK-NEXT: Running pass: {{.*}}X86ExecutionDomainFixPass
+; CHECK-NEXT: Running pass: BreakFalseDepsPass
+; CHECK-NEXT: Running pass: {{.*}}X86IndirectBranchTrackingPass
+; CHECK-NEXT: Running pass: {{.*}}X86IssueVZeroUpperPass
+; CHECK-NEXT: Running pass: {{.*}}X86FixupBWInstsPass
+; CHECK-NEXT: Running pass: {{.*}}X86PadShortFunctionsPass
+; CHECK-NEXT: Running pass: {{.*}}X86FixupLEAsPass
+; CHECK-NEXT: Running pass: {{.*}}X86EvexToVexInstsPass
+; CHECK-NEXT: Running pass: {{.*}}X86DiscriminateMemOpsPass
+; CHECK-NEXT: Running pass: {{.*}}X86InsertPrefetchPass
+; CHECK-NEXT: Running pass: {{.*}}X86InsertX87waitPass
+; CHECK-NEXT: Running pass: FuncletLayoutPass
+; CHECK-NEXT: Running pass: StackMapLivenessPass
+; CHECK-NEXT: Running pass: LiveDebugValuesPass
+; CHECK-NEXT: Running pass: {{.*}}X86RetpolineThunksPass
+; CHECK-NEXT: Running pass: CFIInstrInserterPass
+; CHECK-NEXT: Running pass: {{.*}}X86AsmPrinterPass
+; CHECK-NEXT: Finished llvm::MachineFunction pass manager run.
+
+define void @f() {
+ ret void
+}