diff --git a/lldb/source/Commands/CommandObjectReproducer.cpp b/lldb/source/Commands/CommandObjectReproducer.cpp
index 895a9cc..fcfeb58 100644
--- a/lldb/source/Commands/CommandObjectReproducer.cpp
+++ b/lldb/source/Commands/CommandObjectReproducer.cpp
@@ -8,6 +8,7 @@
 
 #include "CommandObjectReproducer.h"
 
+#include "lldb/Host/OptionParser.h"
 #include "lldb/Utility/Reproducer.h"
 
 #include "lldb/Interpreter/CommandInterpreter.h"
@@ -16,7 +17,52 @@
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 
 using namespace lldb;
+using namespace llvm;
 using namespace lldb_private;
+using namespace lldb_private::repro;
+
+enum ReproducerProvider {
+  eReproducerProviderCommands,
+  eReproducerProviderFiles,
+  eReproducerProviderGDB,
+  eReproducerProviderVersion,
+  eReproducerProviderNone
+};
+
+static constexpr OptionEnumValueElement g_reproducer_provider_type[] = {
+    {
+        eReproducerProviderCommands,
+        "commands",
+        "Command Interpreter Commands",
+    },
+    {
+        eReproducerProviderFiles,
+        "files",
+        "Files",
+    },
+    {
+        eReproducerProviderGDB,
+        "gdb",
+        "GDB Remote Packets",
+    },
+    {
+        eReproducerProviderVersion,
+        "version",
+        "Version",
+    },
+    {
+        eReproducerProviderNone,
+        "none",
+        "None",
+    },
+};
+
+static constexpr OptionEnumValues ReproducerProviderType() {
+  return OptionEnumValues(g_reproducer_provider_type);
+}
+
+#define LLDB_OPTIONS_reproducer
+#include "CommandOptions.inc"
 
 class CommandObjectReproducerGenerate : public CommandObjectParsed {
 public:
@@ -38,7 +84,7 @@
       return false;
     }
 
-    auto &r = repro::Reproducer::Instance();
+    auto &r = Reproducer::Instance();
     if (auto generator = r.GetGenerator()) {
       generator->Keep();
     } else if (r.GetLoader()) {
@@ -84,7 +130,7 @@
       return false;
     }
 
-    auto &r = repro::Reproducer::Instance();
+    auto &r = Reproducer::Instance();
     if (r.GetGenerator()) {
       result.GetOutputStream() << "Reproducer is in capture mode.\n";
     } else if (r.GetLoader()) {
@@ -98,6 +144,191 @@
   }
 };
 
+static void SetError(CommandReturnObject &result, Error err) {
+  result.GetErrorStream().Printf("error: %s\n",
+                                 toString(std::move(err)).c_str());
+  result.SetStatus(eReturnStatusFailed);
+}
+
+class CommandObjectReproducerDump : public CommandObjectParsed {
+public:
+  CommandObjectReproducerDump(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "reproducer dump",
+                            "Dump the information contained in a reproducer.",
+                            nullptr) {}
+
+  ~CommandObjectReproducerDump() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options(), file() {}
+
+    ~CommandOptions() override = default;
+
+    Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
+                          ExecutionContext *execution_context) override {
+      Status error;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'f':
+        file.SetFile(option_arg, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(file);
+        break;
+      case 'p':
+        provider = (ReproducerProvider)OptionArgParser::ToOptionEnum(
+            option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
+        if (!error.Success())
+          error.SetErrorStringWithFormat("unrecognized value for provider '%s'",
+                                         option_arg.str().c_str());
+        break;
+      default:
+        llvm_unreachable("Unimplemented option");
+      }
+
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      file.Clear();
+      provider = eReproducerProviderNone;
+    }
+
+    ArrayRef<OptionDefinition> GetDefinitions() override {
+      return makeArrayRef(g_reproducer_options);
+    }
+
+    FileSpec file;
+    ReproducerProvider provider = eReproducerProviderNone;
+  };
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!command.empty()) {
+      result.AppendErrorWithFormat("'%s' takes no arguments",
+                                   m_cmd_name.c_str());
+      return false;
+    }
+
+    // If no reproducer path is specified, use the loader currently used for
+    // replay. Otherwise create a new loader just for dumping.
+    llvm::Optional<Loader> loader_storage;
+    Loader *loader = nullptr;
+    if (!m_options.file) {
+      loader = Reproducer::Instance().GetLoader();
+      if (loader == nullptr) {
+        result.SetError(
+            "Not specifying a reproducer is only support during replay.");
+        result.SetStatus(eReturnStatusSuccessFinishNoResult);
+        return false;
+      }
+    } else {
+      loader_storage.emplace(m_options.file);
+      loader = &(*loader_storage);
+      if (Error err = loader->LoadIndex()) {
+        SetError(result, std::move(err));
+        return false;
+      }
+    }
+
+    // If we get here we should have a valid loader.
+    assert(loader);
+
+    switch (m_options.provider) {
+    case eReproducerProviderFiles: {
+      FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>();
+
+      // Read the VFS mapping.
+      ErrorOr<std::unique_ptr<MemoryBuffer>> buffer =
+          vfs::getRealFileSystem()->getBufferForFile(vfs_mapping.GetPath());
+      if (!buffer) {
+        SetError(result, errorCodeToError(buffer.getError()));
+        return false;
+      }
+
+      // Initialize a VFS from the given mapping.
+      IntrusiveRefCntPtr<vfs::FileSystem> vfs = vfs::getVFSFromYAML(
+          std::move(buffer.get()), nullptr, vfs_mapping.GetPath());
+
+      // Dump the VFS to a buffer.
+      std::string str;
+      raw_string_ostream os(str);
+      static_cast<vfs::RedirectingFileSystem &>(*vfs).dump(os);
+      os.flush();
+
+      // Return the string.
+      result.AppendMessage(str);
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+    case eReproducerProviderVersion: {
+      FileSpec version_file = loader->GetFile<VersionProvider::Info>();
+
+      // Load the version info into a buffer.
+      ErrorOr<std::unique_ptr<MemoryBuffer>> buffer =
+          vfs::getRealFileSystem()->getBufferForFile(version_file.GetPath());
+      if (!buffer) {
+        SetError(result, errorCodeToError(buffer.getError()));
+        return false;
+      }
+
+      // Return the version string.
+      StringRef version = (*buffer)->getBuffer();
+      result.AppendMessage(version.str());
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+    case eReproducerProviderCommands: {
+      // Create a new command loader.
+      std::unique_ptr<repro::CommandLoader> command_loader =
+          repro::CommandLoader::Create(loader);
+      if (!command_loader) {
+        SetError(result,
+                 make_error<StringError>(llvm::inconvertibleErrorCode(),
+                                         "Unable to create command loader."));
+        return false;
+      }
+
+      // Iterate over the command files and dump them.
+      while (true) {
+        llvm::Optional<std::string> command_file =
+            command_loader->GetNextFile();
+        if (!command_file)
+          break;
+
+        auto command_buffer = llvm::MemoryBuffer::getFile(*command_file);
+        if (auto err = command_buffer.getError()) {
+          SetError(result, errorCodeToError(err));
+          return false;
+        }
+        result.AppendMessage((*command_buffer)->getBuffer());
+      }
+
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+    case eReproducerProviderGDB: {
+      // FIXME: Dumping the GDB remote packets means moving the
+      // (de)serialization code out of the GDB-remote plugin.
+      result.AppendMessage("Dumping GDB remote packets isn't implemented yet.");
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+    case eReproducerProviderNone:
+      result.SetError("No valid provider specified.");
+      return false;
+    }
+
+    result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    return result.Succeeded();
+  }
+
+private:
+  CommandOptions m_options;
+};
+
 CommandObjectReproducer::CommandObjectReproducer(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
@@ -109,6 +340,8 @@
       CommandObjectSP(new CommandObjectReproducerGenerate(interpreter)));
   LoadSubCommand("status", CommandObjectSP(
                                new CommandObjectReproducerStatus(interpreter)));
+  LoadSubCommand("dump",
+                 CommandObjectSP(new CommandObjectReproducerDump(interpreter)));
 }
 
 CommandObjectReproducer::~CommandObjectReproducer() = default;