diff --git a/mlir/include/mlir/Pass/PassManager.h b/mlir/include/mlir/Pass/PassManager.h
index 8f8217e..27c1050 100644
--- a/mlir/include/mlir/Pass/PassManager.h
+++ b/mlir/include/mlir/Pass/PassManager.h
@@ -109,7 +109,7 @@
 };
 
 /// The main pass manager and pipeline builder.
-class PassManager {
+class PassManager : public OpPassManager {
 public:
   // If verifyPasses is true, the verifier is run after each pass.
   PassManager(MLIRContext *ctx, bool verifyPasses = true);
@@ -123,25 +123,6 @@
   void disableMultithreading(bool disable = true);
 
   //===--------------------------------------------------------------------===//
-  // Pipeline Building
-  //===--------------------------------------------------------------------===//
-
-  /// Allow converting to the impl OpPassManager.
-  operator OpPassManager &() { return opPassManager; }
-
-  /// Add an opaque pass pointer to the current manager. This takes ownership
-  /// over the provided pass pointer.
-  void addPass(std::unique_ptr<Pass> pass);
-
-  /// Allow nesting other operation pass managers.
-  OpPassManager &nest(const OperationName &nestedName) {
-    return opPassManager.nest(nestedName);
-  }
-  template <typename OpT> OpPassManager &nest() {
-    return opPassManager.nest<OpT>();
-  }
-
-  //===--------------------------------------------------------------------===//
   // Instrumentations
   //===--------------------------------------------------------------------===//
 
@@ -169,9 +150,6 @@
       PassTimingDisplayMode displayMode = PassTimingDisplayMode::Pipeline);
 
 private:
-  /// The top level pass manager instance.
-  OpPassManager opPassManager;
-
   /// Flag that specifies if pass timing is enabled.
   bool passTiming : 1;
 
diff --git a/mlir/include/mlir/Pass/PassRegistry.h b/mlir/include/mlir/Pass/PassRegistry.h
index eea3778..3feffa1 100644
--- a/mlir/include/mlir/Pass/PassRegistry.h
+++ b/mlir/include/mlir/Pass/PassRegistry.h
@@ -32,11 +32,11 @@
 #include <memory>
 
 namespace mlir {
+class OpPassManager;
 class Pass;
-class PassManager;
 
 /// A registry function that adds passes to the given pass manager.
-using PassRegistryFunction = std::function<void(PassManager &)>;
+using PassRegistryFunction = std::function<void(OpPassManager &)>;
 
 using PassAllocatorFunction = std::function<std::unique_ptr<Pass>()>;
 
@@ -44,14 +44,18 @@
 /// act as a unique identifier during pass registration.
 using PassID = ClassID;
 
+//===----------------------------------------------------------------------===//
+// PassRegistry
+//===----------------------------------------------------------------------===//
+
 /// Structure to group information about a passes and pass pipelines (argument
 /// to invoke via mlir-opt, description, pass pipeline builder).
 class PassRegistryEntry {
 public:
   /// Adds this pass registry entry to the given pass manager.
-  void addToPipeline(PassManager &pm) const {
+  void addToPipeline(OpPassManager &pm) const {
     assert(builder &&
-           "Cannot call addToPipeline on PassRegistryEntry without builder");
+           "cannot call addToPipeline on PassRegistryEntry without builder");
     builder(pm);
   }
 
@@ -95,6 +99,10 @@
            PassAllocatorFunction allocator);
 };
 
+//===----------------------------------------------------------------------===//
+// PassRegistration
+//===----------------------------------------------------------------------===//
+
 /// Register a specific dialect pipeline registry function with the system,
 /// typically used through the PassPipelineRegistration template.
 void registerPassPipeline(StringRef arg, StringRef description,
@@ -134,7 +142,7 @@
 /// Usage:
 ///
 ///   // At namespace scope.
-///   void pipelineBuilder(PassManager &pm) {
+///   void pipelineBuilder(OpPassManager &pm) {
 ///      pm.addPass(new MyPass());
 ///      pm.addPass(new MyOtherPass());
 ///   }
@@ -154,15 +162,40 @@
                            PassAllocatorFunction allocator);
 };
 
-/// Adds command line option for each registered pass.
-struct PassNameParser : public llvm::cl::parser<const PassRegistryEntry *> {
-  PassNameParser(llvm::cl::Option &opt);
+//===----------------------------------------------------------------------===//
+// PassPipelineCLParser
+//===----------------------------------------------------------------------===//
 
-  void initialize();
+namespace detail {
+struct PassPipelineCLParserImpl;
+} // end namespace detail
 
-  void printOptionInfo(const llvm::cl::Option &O,
-                       size_t GlobalWidth) const override;
+/// This class implements a command-line parser for MLIR passes. It registers a
+/// cl option with a given argument and description. This parser will register
+/// options for each of the passes and pipelines that have been registered with
+/// the pass registry; Meaning that `-cse` will refer to the CSE pass in MLIR.
+/// It also registers an argument, `pass-pipeline`, that supports parsing a
+/// textual description of a pipeline.
+class PassPipelineCLParser {
+public:
+  /// Construct a pass pipeline parser with the given command line description.
+  PassPipelineCLParser(StringRef arg, StringRef description);
+  ~PassPipelineCLParser();
+
+  /// Returns true if this parser contains any valid options to add.
+  bool hasAnyOccurrences() const;
+
+  /// Returns true if the given pass registry entry was registered at the
+  /// top-level of the parser, i.e. not within an explicit textual pipeline.
+  bool contains(const PassRegistryEntry *entry) const;
+
+  /// Adds the passes defined by this parser entry to the given pass manager.
+  void addToPipeline(OpPassManager &pm) const;
+
+private:
+  std::unique_ptr<detail::PassPipelineCLParserImpl> impl;
 };
+
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASSREGISTRY_H_
diff --git a/mlir/include/mlir/Support/MlirOptMain.h b/mlir/include/mlir/Support/MlirOptMain.h
index 00a1e48..66b1a87 100644
--- a/mlir/include/mlir/Support/MlirOptMain.h
+++ b/mlir/include/mlir/Support/MlirOptMain.h
@@ -28,11 +28,12 @@
 } // end namespace llvm
 namespace mlir {
 struct LogicalResult;
-class PassRegistryEntry;
+class PassPipelineCLParser;
 
-LogicalResult
-MlirOptMain(llvm::raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> buffer,
-            const std::vector<const PassRegistryEntry *> &passList,
-            bool splitInputFile, bool verifyDiagnostics, bool verifyPasses);
+LogicalResult MlirOptMain(llvm::raw_ostream &os,
+                          std::unique_ptr<llvm::MemoryBuffer> buffer,
+                          const PassPipelineCLParser &passPipeline,
+                          bool splitInputFile, bool verifyDiagnostics,
+                          bool verifyPasses);
 
 } // end namespace mlir
diff --git a/mlir/lib/Pass/Pass.cpp b/mlir/lib/Pass/Pass.cpp
index 1de3025..ee5ad2e 100644
--- a/mlir/lib/Pass/Pass.cpp
+++ b/mlir/lib/Pass/Pass.cpp
@@ -438,7 +438,7 @@
 //===----------------------------------------------------------------------===//
 
 PassManager::PassManager(MLIRContext *ctx, bool verifyPasses)
-    : opPassManager(OperationName(ModuleOp::getOperationName(), ctx),
+    : OpPassManager(OperationName(ModuleOp::getOperationName(), ctx),
                     /*disableThreads=*/false, verifyPasses),
       passTiming(false) {}
 
@@ -448,22 +448,16 @@
 LogicalResult PassManager::run(ModuleOp module) {
   // Before running, make sure to coalesce any adjacent pass adaptors in the
   // pipeline.
-  opPassManager.getImpl().coalesceAdjacentAdaptorPasses();
+  getImpl().coalesceAdjacentAdaptorPasses();
 
   // Construct an analysis manager for the pipeline and run it.
   ModuleAnalysisManager am(module, instrumentor.get());
-  return opPassManager.run(module, am);
+  return OpPassManager::run(module, am);
 }
 
 /// Disable support for multi-threading within the pass manager.
 void PassManager::disableMultithreading(bool disable) {
-  opPassManager.getImpl().disableThreads = disable;
-}
-
-/// Add an opaque pass pointer to the current manager. This takes ownership
-/// over the provided pass pointer.
-void PassManager::addPass(std::unique_ptr<Pass> pass) {
-  opPassManager.addPass(std::move(pass));
+  getImpl().disableThreads = disable;
 }
 
 /// Add the provided instrumentation to the pass manager. This takes ownership
diff --git a/mlir/lib/Pass/PassManagerOptions.cpp b/mlir/lib/Pass/PassManagerOptions.cpp
index 055e81cb..5701d30 100644
--- a/mlir/lib/Pass/PassManagerOptions.cpp
+++ b/mlir/lib/Pass/PassManagerOptions.cpp
@@ -25,9 +25,6 @@
 
 namespace {
 struct PassManagerOptions {
-  typedef llvm::cl::list<const mlir::PassRegistryEntry *, bool, PassNameParser>
-      PassOptionList;
-
   PassManagerOptions();
 
   //===--------------------------------------------------------------------===//
@@ -38,8 +35,8 @@
   //===--------------------------------------------------------------------===//
   // IR Printing
   //===--------------------------------------------------------------------===//
-  PassOptionList printBefore;
-  PassOptionList printAfter;
+  PassPipelineCLParser printBefore;
+  PassPipelineCLParser printAfter;
   llvm::cl::opt<bool> printBeforeAll;
   llvm::cl::opt<bool> printAfterAll;
   llvm::cl::opt<bool> printModuleScope;
@@ -72,10 +69,8 @@
       //===----------------------------------------------------------------===//
       // IR Printing
       //===----------------------------------------------------------------===//
-      printBefore("print-ir-before",
-                  llvm::cl::desc("Print IR before specified passes")),
-      printAfter("print-ir-after",
-                 llvm::cl::desc("Print IR after specified passes")),
+      printBefore("print-ir-before", "Print IR before specified passes"),
+      printAfter("print-ir-after", "Print IR after specified passes"),
       printBeforeAll("print-ir-before-all",
                      llvm::cl::desc("Print IR before each pass"),
                      llvm::cl::init(false)),
@@ -112,12 +107,12 @@
   if (printBeforeAll) {
     // If we are printing before all, then just return true for the filter.
     shouldPrintBeforePass = [](Pass *) { return true; };
-  } else if (printBefore.getNumOccurrences() != 0) {
+  } else if (printBefore.hasAnyOccurrences()) {
     // Otherwise if there are specific passes to print before, then check to see
     // if the pass info for the current pass is included in the list.
     shouldPrintBeforePass = [&](Pass *pass) {
       auto *passInfo = pass->lookupPassInfo();
-      return passInfo && llvm::is_contained(printBefore, passInfo);
+      return passInfo && printBefore.contains(passInfo);
     };
   }
 
@@ -125,12 +120,12 @@
   if (printAfterAll) {
     // If we are printing after all, then just return true for the filter.
     shouldPrintAfterPass = [](Pass *) { return true; };
-  } else if (printAfter.getNumOccurrences() != 0) {
+  } else if (printAfter.hasAnyOccurrences()) {
     // Otherwise if there are specific passes to print after, then check to see
     // if the pass info for the current pass is included in the list.
     shouldPrintAfterPass = [&](Pass *pass) {
       auto *passInfo = pass->lookupPassInfo();
-      return passInfo && llvm::is_contained(printAfter, passInfo);
+      return passInfo && printAfter.contains(passInfo);
     };
   }
 
diff --git a/mlir/lib/Pass/PassRegistry.cpp b/mlir/lib/Pass/PassRegistry.cpp
index 0d85761..4da4515 100644
--- a/mlir/lib/Pass/PassRegistry.cpp
+++ b/mlir/lib/Pass/PassRegistry.cpp
@@ -22,6 +22,7 @@
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace mlir;
+using namespace detail;
 
 /// Static mapping of all of the registered passes.
 static llvm::ManagedStatic<llvm::DenseMap<const PassID *, PassInfo>>
@@ -34,7 +35,7 @@
 /// Utility to create a default registry function from a pass instance.
 static PassRegistryFunction
 buildDefaultRegistryFn(PassAllocatorFunction allocator) {
-  return [=](PassManager &pm) { pm.addPass(allocator()); };
+  return [=](OpPassManager &pm) { pm.addPass(allocator()); };
 }
 
 //===----------------------------------------------------------------------===//
@@ -83,14 +84,252 @@
 }
 
 //===----------------------------------------------------------------------===//
+// TextualPassPipeline Parser
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// This class represents a textual description of a pass pipeline.
+class TextualPipeline {
+public:
+  /// Try to initialize this pipeline with the given pipeline text. An option is
+  /// given to enable accurate error reporting.
+  LogicalResult initialize(StringRef text, llvm::cl::Option &opt);
+
+  /// Add the internal pipeline elements to the provided pass manager.
+  void addToPipeline(OpPassManager &pm) const;
+
+private:
+  /// A struct to capture parsed pass pipeline names.
+  ///
+  /// A pipeline is defined as a series of names, each of which may in itself
+  /// recursively contain a nested pipeline. A name is either the name of a pass
+  /// (e.g. "cse") or the name of an operation type (e.g. "func"). If the name
+  /// is the name of a pass, the InnerPipeline is empty, since passes cannot
+  /// contain inner pipelines.
+  struct PipelineElement {
+    StringRef name;
+    const PassRegistryEntry *registryEntry;
+    std::vector<PipelineElement> innerPipeline;
+  };
+
+  /// Parse the given pipeline text into the internal pipeline vector. This
+  /// function only parses the structure of the pipeline, and does not resolve
+  /// its elements.
+  LogicalResult parsePipelineText(StringRef text, llvm::cl::Option &opt);
+
+  /// Resolve the elements of the pipeline, i.e. connect passes and pipelines to
+  /// the corresponding registry entry.
+  LogicalResult
+  resolvePipelineElements(MutableArrayRef<PipelineElement> elements,
+                          llvm::cl::Option &opt);
+
+  /// Resolve a single element of the pipeline.
+  LogicalResult resolvePipelineElement(PipelineElement &element,
+                                       llvm::cl::Option &opt);
+
+  /// Add the given pipeline elements to the provided pass manager.
+  void addToPipeline(ArrayRef<PipelineElement> elements,
+                     OpPassManager &pm) const;
+
+  std::vector<PipelineElement> pipeline;
+};
+
+} // end anonymous namespace
+
+/// Try to initialize this pipeline with the given pipeline text. An option is
+/// given to enable accurate error reporting.
+LogicalResult TextualPipeline::initialize(StringRef text,
+                                          llvm::cl::Option &opt) {
+  // Parse the provided pipeline string.
+  if (failed(parsePipelineText(text, opt)))
+    return failure(opt.error("failed to parse pass pipeline: `" + text + "'"));
+  return resolvePipelineElements(pipeline, opt);
+}
+
+/// Add the internal pipeline elements to the provided pass manager.
+void TextualPipeline::addToPipeline(OpPassManager &pm) const {
+  addToPipeline(pipeline, pm);
+}
+
+/// Parse the given pipeline text into the internal pipeline vector. This
+/// function only parses the structure of the pipeline, and does not resolve
+/// its elements.
+LogicalResult TextualPipeline::parsePipelineText(StringRef text,
+                                                 llvm::cl::Option &opt) {
+  SmallVector<std::vector<PipelineElement> *, 4> pipelineStack = {&pipeline};
+  for (;;) {
+    std::vector<PipelineElement> &pipeline = *pipelineStack.back();
+    size_t pos = text.find_first_of(",()");
+    pipeline.push_back({text.substr(0, pos).trim(), {}});
+
+    // If we have a single terminating name, we're done.
+    if (pos == text.npos)
+      break;
+
+    char sep = text[pos];
+    text = text.substr(pos + 1);
+
+    // Just a name ending in a comma, continue.
+    if (sep == ',')
+      continue;
+
+    if (sep == '(') {
+      // Push the inner pipeline onto the stack to continue processing.
+      pipelineStack.push_back(&pipeline.back().innerPipeline);
+      continue;
+    }
+
+    // When handling the close parenthesis, we greedily consume them to avoid
+    // empty strings in the pipeline.
+    assert(sep == ')' && "Bogus separator!");
+    do {
+      // If we try to pop the outer pipeline we have unbalanced parentheses.
+      if (pipelineStack.size() == 1)
+        return failure(
+            opt.error("encountered extra closing ')' creating unbalanced "
+                      "parentheses while parsing pipeline"));
+
+      pipelineStack.pop_back();
+    } while (text.consume_front(")"));
+
+    // Check if we've finished parsing.
+    if (text.empty())
+      break;
+
+    // Otherwise, the end of an inner pipeline always has to be followed by
+    // a comma, and then we can continue.
+    if (!text.consume_front(","))
+      return failure(opt.error("expected ',' after parsing pipeline near: " +
+                               pipeline.back().name));
+  }
+
+  // Check for unbalanced parentheses.
+  if (pipelineStack.size() > 1)
+    return failure(
+        opt.error("encountered unbalanced parentheses while parsing pipeline"));
+
+  assert(pipelineStack.back() == &pipeline &&
+         "wrong pipeline at the bottom of the stack");
+  return success();
+}
+
+/// Resolve the elements of the pipeline, i.e. connect passes and pipelines to
+/// the corresponding registry entry.
+LogicalResult TextualPipeline::resolvePipelineElements(
+    MutableArrayRef<PipelineElement> elements, llvm::cl::Option &opt) {
+  for (auto &elt : elements)
+    if (failed(resolvePipelineElement(elt, opt)))
+      return failure();
+  return success();
+}
+
+/// Resolve a single element of the pipeline.
+LogicalResult TextualPipeline::resolvePipelineElement(PipelineElement &element,
+                                                      llvm::cl::Option &opt) {
+  // If the inner pipeline of this element is not empty, this is an operation
+  // pipeline.
+  if (!element.innerPipeline.empty())
+    return resolvePipelineElements(element.innerPipeline, opt);
+
+  // Otherwise, this must be a pass or pass pipeline.
+  // Check to see if a pipeline was registered with this name.
+  auto pipelineRegistryIt = passPipelineRegistry->find(element.name);
+  if (pipelineRegistryIt != passPipelineRegistry->end()) {
+    element.registryEntry = &pipelineRegistryIt->second;
+    return success();
+  }
+
+  // If not, then this must be a specific pass name.
+  for (auto &passIt : *passRegistry) {
+    if (passIt.second.getPassArgument() == element.name) {
+      element.registryEntry = &passIt.second;
+      return success();
+    }
+  }
+
+  // Emit an error for the unknown pass.
+  opt.error("'" + element.name +
+            "' does not refer to a registered pass or pass pipeline");
+  return failure();
+}
+
+/// Add the given pipeline elements to the provided pass manager.
+void TextualPipeline::addToPipeline(ArrayRef<PipelineElement> elements,
+                                    OpPassManager &pm) const {
+  for (auto &elt : elements) {
+    if (elt.registryEntry)
+      elt.registryEntry->addToPipeline(pm);
+    else
+      addToPipeline(elt.innerPipeline, pm.nest(elt.name));
+  }
+}
+
+//===----------------------------------------------------------------------===//
 // PassNameParser
 //===----------------------------------------------------------------------===//
 
-PassNameParser::PassNameParser(llvm::cl::Option &opt)
-    : llvm::cl::parser<const PassRegistryEntry *>(opt) {}
+namespace {
+/// This struct represents the possible data entries in a parsed pass pipeline
+/// list.
+struct PassArgData {
+  PassArgData() : registryEntry(nullptr) {}
+  PassArgData(const PassRegistryEntry *registryEntry)
+      : registryEntry(registryEntry) {}
+
+  /// This field is used when the parsed option corresponds to a registered pass
+  /// or pass pipeline.
+  const PassRegistryEntry *registryEntry;
+
+  /// This field is used when the parsed option corresponds to an explicit
+  /// pipeline.
+  TextualPipeline pipeline;
+};
+} // end anonymous namespace
+
+namespace llvm {
+namespace cl {
+/// Define a valid OptionValue for the command line pass argument.
+template <>
+struct OptionValue<PassArgData> final
+    : OptionValueBase<PassArgData, /*isClass=*/true> {
+  OptionValue(const PassArgData &value) { this->setValue(value); }
+  OptionValue() = default;
+  void anchor() override {}
+
+  bool hasValue() const { return true; }
+  const PassArgData &getValue() const { return value; }
+  void setValue(const PassArgData &value) { this->value = value; }
+
+  PassArgData value;
+};
+} // end namespace cl
+} // end namespace llvm
+
+namespace {
+
+/// The name for the command line option used for parsing the textual pass
+/// pipeline.
+static constexpr llvm::StringLiteral passPipelineArg = "pass-pipeline";
+
+/// Adds command line option for each registered pass or pass pipeline, as well
+/// as textual pass pipelines.
+struct PassNameParser : public llvm::cl::parser<PassArgData> {
+  PassNameParser(llvm::cl::Option &opt) : llvm::cl::parser<PassArgData>(opt) {}
+
+  void initialize();
+  void printOptionInfo(const llvm::cl::Option &opt,
+                       size_t globalWidth) const override;
+  bool parse(llvm::cl::Option &opt, StringRef argName, StringRef arg,
+             PassArgData &value);
+};
+} // namespace
 
 void PassNameParser::initialize() {
-  llvm::cl::parser<const PassRegistryEntry *>::initialize();
+  llvm::cl::parser<PassArgData>::initialize();
+
+  /// Add an entry for the textual pass pipeline option.
+  addLiteralOption(passPipelineArg, PassArgData(),
+                   "A textual description of a pass pipeline to run");
 
   /// Add the pass entries.
   for (const auto &kv : *passRegistry) {
@@ -112,6 +351,62 @@
                           const PassNameParser::OptionInfo *VT2) {
                          return VT1->Name.compare(VT2->Name);
                        });
-  using llvm::cl::parser;
-  parser<const PassRegistryEntry *>::printOptionInfo(O, GlobalWidth);
+  llvm::cl::parser<PassArgData>::printOptionInfo(O, GlobalWidth);
+}
+
+bool PassNameParser::parse(llvm::cl::Option &opt, StringRef argName,
+                           StringRef arg, PassArgData &value) {
+  // Handle the pipeline option explicitly.
+  if (argName == passPipelineArg)
+    return failed(value.pipeline.initialize(arg, opt));
+
+  // Otherwise, default to the base for handling.
+  return llvm::cl::parser<PassArgData>::parse(opt, argName, arg, value);
+}
+
+//===----------------------------------------------------------------------===//
+// PassPipelineCLParser
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace detail {
+struct PassPipelineCLParserImpl {
+  PassPipelineCLParserImpl(StringRef arg, StringRef description)
+      : passList(arg, llvm::cl::desc(description)) {
+    passList.setValueExpectedFlag(llvm::cl::ValueExpected::ValueOptional);
+  }
+
+  /// The set of passes and pass pipelines to run.
+  llvm::cl::list<PassArgData, bool, PassNameParser> passList;
+};
+} // end namespace detail
+} // end namespace mlir
+
+/// Construct a pass pipeline parser with the given command line description.
+PassPipelineCLParser::PassPipelineCLParser(StringRef arg, StringRef description)
+    : impl(std::make_unique<detail::PassPipelineCLParserImpl>(arg,
+                                                              description)) {}
+PassPipelineCLParser::~PassPipelineCLParser() {}
+
+/// Returns true if this parser contains any valid options to add.
+bool PassPipelineCLParser::hasAnyOccurrences() const {
+  return impl->passList.getNumOccurrences() != 0;
+}
+
+/// Returns true if the given pass registry entry was registered at the
+/// top-level of the parser, i.e. not within an explicit textual pipeline.
+bool PassPipelineCLParser::contains(const PassRegistryEntry *entry) const {
+  return llvm::any_of(impl->passList, [&](const PassArgData &data) {
+    return data.registryEntry == entry;
+  });
+}
+
+/// Adds the passes defined by this parser entry to the given pass manager.
+void PassPipelineCLParser::addToPipeline(OpPassManager &pm) const {
+  for (auto &passIt : impl->passList) {
+    if (passIt.registryEntry)
+      passIt.registryEntry->addToPipeline(pm);
+    else
+      passIt.pipeline.addToPipeline(pm);
+  }
 }
diff --git a/mlir/lib/Support/MlirOptMain.cpp b/mlir/lib/Support/MlirOptMain.cpp
index 0b234e6..055692d 100644
--- a/mlir/lib/Support/MlirOptMain.cpp
+++ b/mlir/lib/Support/MlirOptMain.cpp
@@ -45,10 +45,10 @@
 /// This typically parses the main source file, runs zero or more optimization
 /// passes, then prints the output.
 ///
-static LogicalResult
-performActions(raw_ostream &os, bool verifyDiagnostics, bool verifyPasses,
-               SourceMgr &sourceMgr, MLIRContext *context,
-               const std::vector<const mlir::PassRegistryEntry *> &passList) {
+static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,
+                                    bool verifyPasses, SourceMgr &sourceMgr,
+                                    MLIRContext *context,
+                                    const PassPipelineCLParser &passPipeline) {
   OwningModuleRef module(parseSourceFile(sourceMgr, context));
   if (!module)
     return failure();
@@ -57,9 +57,8 @@
   PassManager pm(context, verifyPasses);
   applyPassManagerCLOptions(pm);
 
-  // Run each of the passes that were selected.
-  for (const auto *passEntry : passList)
-    passEntry->addToPipeline(pm);
+  // Build the provided pipeline.
+  passPipeline.addToPipeline(pm);
 
   // Run the pipeline.
   if (failed(pm.run(*module)))
@@ -72,10 +71,10 @@
 
 /// Parses the memory buffer.  If successfully, run a series of passes against
 /// it and print the result.
-static LogicalResult
-processBuffer(raw_ostream &os, std::unique_ptr<MemoryBuffer> ownedBuffer,
-              bool verifyDiagnostics, bool verifyPasses,
-              const std::vector<const mlir::PassRegistryEntry *> &passList) {
+static LogicalResult processBuffer(raw_ostream &os,
+                                   std::unique_ptr<MemoryBuffer> ownedBuffer,
+                                   bool verifyDiagnostics, bool verifyPasses,
+                                   const PassPipelineCLParser &passPipeline) {
   // Tell sourceMgr about this buffer, which is what the parser will pick up.
   SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
@@ -88,7 +87,7 @@
   if (!verifyDiagnostics) {
     SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
     return performActions(os, verifyDiagnostics, verifyPasses, sourceMgr,
-                          &context, passList);
+                          &context, passPipeline);
   }
 
   SourceMgrDiagnosticVerifierHandler sourceMgrHandler(sourceMgr, &context);
@@ -97,7 +96,7 @@
   // these actions succeed or fail, we only care what diagnostics they produce
   // and whether they match our expectations.
   performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
-                 passList);
+                 passPipeline);
 
   // Verify the diagnostic handler to make sure that each of the diagnostics
   // matched.
@@ -108,10 +107,11 @@
 /// according to the normal processBuffer logic.  This is primarily used to
 /// allow a large number of small independent parser tests to be put into a
 /// single test, but could be used for other purposes as well.
-static LogicalResult splitAndProcessFile(
-    raw_ostream &os, std::unique_ptr<MemoryBuffer> originalBuffer,
-    bool verifyDiagnostics, bool verifyPasses,
-    const std::vector<const mlir::PassRegistryEntry *> &passList) {
+static LogicalResult
+splitAndProcessFile(raw_ostream &os,
+                    std::unique_ptr<MemoryBuffer> originalBuffer,
+                    bool verifyDiagnostics, bool verifyPasses,
+                    const PassPipelineCLParser &passPipeline) {
   const char marker[] = "// -----";
   auto *origMemBuffer = originalBuffer.get();
   SmallVector<StringRef, 8> sourceBuffers;
@@ -132,24 +132,24 @@
         subBuffer, origMemBuffer->getBufferIdentifier() +
                        Twine(" split at line #") + Twine(splitLine));
     if (failed(processBuffer(os, std::move(subMemBuffer), verifyDiagnostics,
-                             verifyPasses, passList)))
+                             verifyPasses, passPipeline)))
       hadUnexpectedResult = true;
   }
 
   return failure(hadUnexpectedResult);
 }
 
-LogicalResult
-mlir::MlirOptMain(raw_ostream &os, std::unique_ptr<MemoryBuffer> buffer,
-                  const std::vector<const mlir::PassRegistryEntry *> &passList,
-                  bool splitInputFile, bool verifyDiagnostics,
-                  bool verifyPasses) {
+LogicalResult mlir::MlirOptMain(raw_ostream &os,
+                                std::unique_ptr<MemoryBuffer> buffer,
+                                const PassPipelineCLParser &passPipeline,
+                                bool splitInputFile, bool verifyDiagnostics,
+                                bool verifyPasses) {
   // The split-input-file mode is a very specific mode that slices the file
   // up into small pieces and checks each independently.
   if (splitInputFile)
     return splitAndProcessFile(os, std::move(buffer), verifyDiagnostics,
-                               verifyPasses, passList);
+                               verifyPasses, passPipeline);
 
   return processBuffer(os, std::move(buffer), verifyDiagnostics, verifyPasses,
-                       passList);
+                       passPipeline);
 }
diff --git a/mlir/test/Pass/pipeline-parsing.mlir b/mlir/test/Pass/pipeline-parsing.mlir
new file mode 100644
index 0000000..6a9c52e
--- /dev/null
+++ b/mlir/test/Pass/pipeline-parsing.mlir
@@ -0,0 +1,31 @@
+// RUN: mlir-opt %s -pass-pipeline='module(test-module-pass,func(test-function-pass)),func(test-function-pass)' -cse -pass-pipeline="func(canonicalize)" -verify-each=false -pass-timing -pass-timing-display=pipeline 2>&1 | FileCheck %s
+// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s
+// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s
+// RUN: not mlir-opt %s -pass-pipeline='module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s
+// RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s
+
+// CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline
+// CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline
+// CHECK_ERROR_3: expected ',' after parsing pipeline
+// CHECK_ERROR_4: does not refer to a registered pass or pass pipeline
+
+func @foo() {
+  return
+}
+
+module {
+  func @foo() {
+    return
+  }
+}
+
+// CHECK: Pipeline Collection : ['func', 'module']
+// CHECK-NEXT:   'func' Pipeline
+// CHECK-NEXT:     TestFunctionPass
+// CHECK-NEXT:     CSE
+// CHECK-NEXT:       DominanceInfo
+// CHECK-NEXT:     Canonicalizer
+// CHECK-NEXT:   'module' Pipeline
+// CHECK-NEXT:     TestModulePass
+// CHECK-NEXT:     'func' Pipeline
+// CHECK-NEXT:       TestFunctionPass
diff --git a/mlir/test/lib/Pass/TestPassManager.cpp b/mlir/test/lib/Pass/TestPassManager.cpp
index 5efb2fb..7e4d8a7 100644
--- a/mlir/test/lib/Pass/TestPassManager.cpp
+++ b/mlir/test/lib/Pass/TestPassManager.cpp
@@ -30,7 +30,7 @@
 };
 } // namespace
 
-static void testNestedPipeline(PassManager &pm) {
+static void testNestedPipeline(OpPassManager &pm) {
   // Nest a module pipeline that contains:
   /// A module pass.
   auto &modulePM = pm.nest<ModuleOp>();
@@ -44,6 +44,11 @@
   functionPM.addPass(std::make_unique<TestFunctionPass>());
 }
 
+static PassRegistration<TestModulePass>
+    unusedMP("test-module-pass", "Test a module pass in the pass manager");
+static PassRegistration<TestFunctionPass>
+    unusedFP("test-function-pass", "Test a function pass in the pass manager");
+
 static PassPipelineRegistration
     unused("test-pm-nested-pipeline",
            "Test a nested pipeline in the pass manager", testNestedPipeline);
diff --git a/mlir/tools/mlir-opt/mlir-opt.cpp b/mlir/tools/mlir-opt/mlir-opt.cpp
index 3f9dbcde..d01f66d 100644
--- a/mlir/tools/mlir-opt/mlir-opt.cpp
+++ b/mlir/tools/mlir-opt/mlir-opt.cpp
@@ -56,18 +56,14 @@
                  cl::desc("Run the verifier after each transformation pass"),
                  cl::init(true));
 
-static std::vector<const PassRegistryEntry *> *passList;
-
 int main(int argc, char **argv) {
   InitLLVM y(argc, argv);
 
   // Register any pass manager command line options.
   registerPassManagerCLOptions();
+  PassPipelineCLParser passPipeline("", "Compiler passes to run");
 
   // Parse pass names in main to ensure static initialization completed.
-  llvm::cl::list<const PassRegistryEntry *, bool, PassNameParser> passList(
-      "", llvm::cl::desc("Compiler passes to run"));
-  ::passList = &passList;
   cl::ParseCommandLineOptions(argc, argv, "MLIR modular optimizer driver\n");
 
   // Set up the input file.
@@ -84,6 +80,6 @@
     exit(1);
   }
 
-  return failed(MlirOptMain(output->os(), std::move(file), passList,
+  return failed(MlirOptMain(output->os(), std::move(file), passPipeline,
                             splitInputFile, verifyDiagnostics, verifyPasses));
 }