WIP: Support: Add vfs::OutputBackend to virtualize compiler outputs

[dexonsmith]

Summary

[This is supporting an RFC (https://lists.llvm.org/pipermail/cfe-dev/2021-January/067576.html / https://lists.llvm.org/pipermail/llvm-dev/2021-January/148124.html); a follow up patch has initial adoption in clang::CompilerInstance; marked WIP for now.]

WIP: Support: Add vfs::OutputBackend to virtualize compiler outputs

Add OutputBackend to the llvm::vfs namespace to virtualize compiler
outputs. The primary interface includes the following API:

• getDirectory() returns an OutputDirectory, which is a proxy backend that uses the requested directory as a working directory.
• createFile() creates a file and returns OutputFile for writing to it.
• createDirectory() creates a directory and then calls getDirectory(). The default implementation assumes creating a directory is a no-op, to support backends that don't have a concept of a directories without files in them.
• createUniqueFile() and createUniqueDirectory(), versions of the above that avoid creating entitity names that already exist. (StableUniqueEntityAdaptor<> can be used by backends that don't have a way to check what exists.)

This patch contains a number of backends, including:

• NullOutputBackend, for silently ignoring all outputs.
• OnDiskOutputBackend, for writing to disk.
• InMemoryOutputBackend, for writing to an InMemoryFileSystem.
• MirroringOutputBackend, for writing to multiple backends.
• FilteringOutputBackend, for filtering which outputs get written to the underlying backend.

There are also a few helpers for creating other backends:

• ProxyOutputBackend forwards all calls to an underlying backend.
• StableUniqueEntityAdaptor<> adds stable implementations of createUniqueFileImpl() and createUniqueDirectoryImpl().

The primary interface for OutputFile includes the following API:

• takeOS() returns a std::unique_ptr<raw_pwrite_stream> for writing (getOS() gives a raw pointer to the stream if it hasn't been taken).
• close() commits the file (to disk, in-memory, etc.).
• getPath() gets the path to the output.
• ~Output erases the output if it hasn't been opened.

OutputFile has support for buffering content. One use case is for
concrete subclasses that don't support streams. Another is to support
passing the same content to multiple underlying OutputFile instances
(such as for MirroringOutputBackend). OutputFile::close() calls
storeContentBuffer() with a ContentBuffer if this support was used;
otherwise, it calls storeStreamedContent().

An OutputConfig is passed when creating a file or directory to
communicate semantics about the output. There are a few flags:

• Text, for outputs that should be opened in text mode.
• Volatile, for outputs that other processes may modify after write. (OnDiskOutputBackend has support for writing its bytes to an mmap'ed region and passing a file-backed buffer on to other backends. This optimization is turned off for Volatile outputs.)
• NoCrashCleanup, for outputs that should not be removed on crash.
• NoAtomicWrite, for outputs that should be written directly, instead of moved atomically into place.
• NoImplyCreateDirectories, for outputs that require the parent path to already exist.
• NoOverwrite, for outputs that are not allowed to clobber any existing content.

Most of these flags are ignorable by backends that aren't associated
with a filesystem.

TODO:

• Fix all the header docs. They've mostly bitrotted.
• Document and enforce threading guarantees. Tentatively, all OutputBackend APIs safe to call concurrently. An OutputFile cannot be used concurrently, but two files from the same backend can be.
• Test OutputDirectory.
• Test createDirectory().
• Test createDirectories().
• Test createUnique*().

[dexonsmith]

RFC is up at https://lists.llvm.org/pipermail/cfe-dev/2021-January/067576.html

[dexonsmith]

In D95501#2524418, @dexonsmith wrote:

RFC is up at https://lists.llvm.org/pipermail/cfe-dev/2021-January/067576.html

(Cross-posted to llvm-dev here: https://lists.llvm.org/pipermail/llvm-dev/2021-January/148124.html.)

[dexonsmith]

Update description and patch following some feedback on the RFC.

• Simplify OutputConfig, restricting it to semantic information about a specific output. Sink all backend configuration to flags on the backends themselves.
• Remove OutputManager, instead exposing OutputBackend directly.
• Merge Output and OutputDestination into a single class called OutputFile, and rename the API for creating them to OutputBackend::createFile().
• Add support for working directories via OutputDirectory, and add OutputBackend::getDirectory() and OutputBackend::createDirectory().
• Add support for createUniqueFile() and createUniqueDirectory(), both heavily used in clang. Backends without read access can use StableUniqueEntityAdaptor to implement these.

[dexonsmith]

rebase

[sammccall]

Some detailed comments to go with the RFC thread!

llvm/include/llvm/Support/OutputBackend.h

64

I think a struct in the style of FrontendOptions or so might have better ergonomics:

• access is a bit more direct
• can easily provide sensible defaults rather than having to negate half the option names

133

It would be helpful for a client to have few "valid" bits to reason about:

• open/closed
• erased/not-erased
• stream taken/not taken

I think erased is gone now, and just remains in the comments, which is nice!
Is it necessary to support both getting and taking the stream, or could we get away with one?

152

Could consider calling this commit, which hints at the behavior when calling vs not calling it.

172

As you mentioned on the mail, this seems a little wrong to expose here, I'd agree with removing it.

I think the only question it really answers is "what string was passed to OutputBackend::createFileImpl" - this may be useful, but it's easily conflated with ideas like "where can I read this file from". So I like the idea that path strings only appear in close proximity to OutputBackends.

177

ContentBuffer seems handy for implementing output-files that buffer in memory, but does support it really need to be baked into the base class?
It causes a confusing structure in OutputFile where half of the interface is about dealing with streams and the other half is dealing with buffers, and it's hard to tell which is fundamental.

My best understanding is that ContentBuffer exists to avoid copies in some cases where the output is buffered into memory. If a copy was OK, we'd just use string/stringref, and if the output was being written to disk, we'd use a stream. It seems surprising if this really is a win overall. Is it possible to start with something simpler and evolve to something fast, with benchmarks?

(If it were gone from the main interface, it seems that it would be simple enough for e.g. InMemoryOutputDestination to implement takeOSImpl() and close() on top of a ContentBuffer member, for MirroringOutput to simply write its buffer to the output stream, etc.)

204

this seems like a surprising place to strike a balance, it implies:

• it's more important to optimize away null in the mirroring file than to encapsulate nullness as an implementation detail
• but it's more important to encapsulate nullness than to optimize in other places (e.g. actually writing output!)

If nullness enables important optimizations (seems plausible) I'd prefer just making this public.

251

ThreadSafeRefCountedBase?

Or even better, can we just use std::shared_ptr?

(I think the nominal reason for still having IntrusiveRefCntPtr is that it's cheaper when thread-safety is not required, but it is here)

262

My understanding is the use of Twine in the VFS interfaces is a (hard-to-fix) mistake - in practice we do not compose paths using techniques that Twines support well, we mostly end up rendering twines to strings to pass them to other APIs anyway, and the potential performance benefits of Twine are unlikely to be meaningful in the face of IO anyway.

Can we use StringRef?

270

This is pretty fuzzy to me - it sounds like this is the API both for creating a directory, and creating an output that encapsulates the notion of working directory.

What do you do if you want only one of these? In particular, if you want to track the output directory but only create if you write any outputs. I guess: you can't use this API, and need to track working directory externally instead.

For backends that *do* have a concept of directory existence, is it *required* to call this function or can you just write to a path and have parent directories created? I guess: it's optional by default but the NoImplyCreateDirectories controls this.

---

These aren't showstoppers, but if something simpler would work equally well, that would be nice. e.g.

• providing "createDirectory" to do the IO, and making OutputDirectory a helper class instead of part of the interface
• only dealing in absolute paths - the platform bundles working-directory handling with IO operations, but it's not like we can actually use the OS's working directory...

437

The patterns here (inheritance, state and templates) seem quite complicated and I'm having a tough time following it.
Is this modeled on existing code somewhere? Maybe we can provide a simpler version of this initially, or leave the unique-entity stuff to separate patches?

437

Stable seems to mean something significant here, but I don't know what it is.

450

I'm not 100% sure of the structure of the stable-entity stuff, but it looks like this state needs to be synchronized for multithreaded access.

601

Can we use errorCodeToError(std::errc::file_exists) for this?

(with createFileError if it's critical to copy the filename in here)

627

this doesn't seem like a useful public API, because temp files and renaming are low-level implementation details of particular backends. Even if you know the backend is in use, it's hard to imaging handling "rename errors" differently than other IO errors, apart from the error message.

Can this be createStringError("Could not rename...", EC) - we do actually have an underlying error code from the OS

703

why is it necessary to allow externally accessing/modifying the settings after construction?

llvm/lib/Support/OutputBackend.cpp

865

doesn't the contract say File1 may have taken the content?

[dexonsmith]

The patch at https://reviews.llvm.org/D133504 incorporates much of the feedback from @sammccall; since @steven_wu has posted it on my behalf, abandoning this one.

llvm/include/llvm/Support/OutputBackend.h

+//===- llvm/Support/OutputBackend.h - Output management ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_OUTPUTBACKEND_H
+#define LLVM_SUPPORT_OUTPUTBACKEND_H
+
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/simple_ilist.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace vfs {
+
+/// Set of advisory flags for backends. By default, all flags are off.
+enum class OutputConfigFlag {
+  /// Files should be opened in text mode. Backends modelling a Windows
+  /// filesystem should translate newlines to carriage returns and line feeds.
+  ///
+  /// Seeking is not supported for text outputs.
+  Text,
+
+  /// Advise that other processes are likely to *modify* this output after it
+  /// has been written (as opposed to replacing it atomically); for example, if
+  /// the output is a source file on-disk, an editor may modify it in place.
+  /// \a OnDiskOutputBackend will disable forwarding write-through buffers in
+  /// this case.
+  Volatile,
+
+  /// No need to clean this up if there's a crash. If set, backends will not
+  /// install \a llvm::RemoveOnSignal or similar, even if configured to do so
+  /// by default.
+  NoCrashCleanup,
+
+  /// This file does not need to be atomically moved into its final path. If
+  /// set, \a OnDiskOutputBackend will not use temporary files, even if it's
+  /// configured to do so by default.
+  NoAtomicWrite,
+
+  /// Do not imply creation of missing directories. Backends that don't have
+  /// directories as a first-class concept are free to ignore this.
+  NoImplyCreateDirectories,
+
+  /// Error if an output already exists and/or would be clobbered. Note: some
+  /// backends only know about files and directories they've created
+  /// themselves.
+  NoOverwrite,
+
+  // Keep this last.
+  NumFlags,
+};
+
+/// Full configuration for an output for use by the \a OutputBackend. Each
+/// configuration flag is either \c true or \c false.
+class OutputConfig {
+  /// Don't use std::bitset since it's mostly not constexpr. If primitive types
+  /// don't have enough bits, this can use a simple constexpr-friendly bitset.
+  using BitsetType = unsigned char;
+
+  /// Construct the combined enumeration from any individual enum.
+  constexpr static BitsetType getBitset(OutputConfigFlag Flag) {
+    static_assert(sizeof(BitsetType) <= sizeof(int),
+                  "Returned literal will overflow");
+    return 1u << static_cast<int>(Flag);
+  }
+
+  /// Check that the flags fit in the bitset.
+  static_assert(static_cast<int>(OutputConfigFlag::NumFlags) <=
+                    sizeof(BitsetType) * 8,
+                "BitsetType ran out of bits");
+
+public:
+  /// Test whether there are no flags turned on.
+  constexpr bool none() const { return !Bits; }
+
+  /// Check the value for \c Flag.
+  constexpr bool test(OutputConfigFlag Flag) const {
+    return Bits & getBitset(Flag);
+  }
+
+  /// Set \c Flag to \c Value.
+  constexpr OutputConfig &set(OutputConfigFlag Flag, bool Value = true) {
+    if (Value)
+      Bits |= getBitset(Flag);
+    else
+      Bits &= ~getBitset(Flag);
+    return *this;
+  }
+
+  /// Set \c Flags to \c Value.
+  constexpr OutputConfig &set(std::initializer_list<OutputConfigFlag> Flags,
+                              bool Value = true) {
+    for (auto Flag : Flags)
+      set(Flag, Value);
+    return *this;
+  }
+
+  /// Set \c Flag to \c false.
+  constexpr OutputConfig &reset(OutputConfigFlag Flag) {
+    return set(Flag, false);
+  }
+
+  /// Set \c Flags to \c false.
+  constexpr OutputConfig &reset(std::initializer_list<OutputConfigFlag> Flags) {
+    return set(Flags, false);
+  }
+
+  /// Nothing is set.
+  constexpr OutputConfig() = default;
+  constexpr OutputConfig(NoneType) {}
+
+  /// Set exactly the flags listed, leaving others turned off.
+  constexpr OutputConfig(std::initializer_list<OutputConfigFlag> OnFlags) {
+    set(OnFlags);
+  }
+
+private:
+  BitsetType Bits = 0;
+};
+
+class OutputBackend;
+
+/// Opaque description of a compiler output that has been created.
+class OutputFile {
+  virtual void anchor();
+
+public:
+  /// Internal utility for holding completed content for an output.
+  class ContentBuffer;
+
+  /// Close an output, finalizing its content and sending it to the configured
+  /// \a OutputBackend.
+  ///
+  /// This destructs the stream if it still owns it and writes the output to
+  /// its final destination(s). E.g., for \a OnDiskOutputBackend, any temporary
+  /// files will get moved into place, or for \a InMemoryOutputBackend, the \a
+  /// MemoryBuffer will be created and stored in the \a InMemoryFileSystem.
+  ///
+  /// \pre If \a takeOS() has been called, the stream should have been
+  /// destructed before calling this function.
+  /// \pre \a isOpen(); i.e., neither \a erase() nor \a close() has been
+  /// called yet.
+  Error close();
+
+  /// Check if \a erase() or \a close() has already been called.
+  bool isOpen() const { return IsOpen; }
+
+  /// Get a pointer to the output stream, if it hasn't been taken.
+  raw_pwrite_stream *getOS() {
+    initializeStreamOnce();
+    return OS.get();
+  }
+
+  /// Take the output stream. This stream should be destructed before calling
+  /// \a close().
+  ///
+  /// \post \a getOS() returns \c nullptr.
+  std::unique_ptr<raw_pwrite_stream> takeOS() {
+    initializeStreamOnce();
+    return std::move(OS);
+  }
+
+  StringRef getPath() const { return Path; }
+
+protected:
+  /// Return a content buffer stream and ask \a close() to call \a
+  /// storeContentBuffer().
+  std::unique_ptr<raw_pwrite_stream> createStreamForContentBuffer();
+
+  /// Override to return a custom stream object and have \a close() call \a
+  /// storeStreamedContent(). The default implementation calls \a
+  /// initializeForContentBuffer() and forwards to \a
+  /// createStreamForContentBuffer().
+  virtual std::unique_ptr<raw_pwrite_stream> takeOSImpl() {
+    return createStreamForContentBuffer();
+  }
+
+  virtual Error storeStreamedContent() {
+    llvm_unreachable("override this if initializeForStreamedContent() returns "
+                     "a stream without calling createStreamForContentBuffer()");
+  }
+
+  virtual Error storeContentBuffer(ContentBuffer &Content) = 0;
+
+  /// Allow subclasses to call \a OutputFile::storeContentBuffer() on other
+  /// files.
+  static Error storeContentBufferIn(ContentBuffer &Content, OutputFile &File) {
+    return File.storeContentBuffer(Content);
+  }
+
+  /// Check if this is /dev/null.
+  virtual bool isNull() const { return false; }
+
+  /// Allow subclasses to call \a OutputFile::isNull() on other files.
+  static bool isNull(const OutputFile &File) { return File.isNull(); }
+
+  /// Allow subclasses to destroy the stream (if it's still owned), in case the
+  /// destructor has side effects.
+  void destroyOS() { OS = nullptr; }
+
+private:
+  void initializeStreamOnce() {
+    if (IsStreamInitialized)
+      return;
+    OS = takeOSImpl();
+    IsStreamInitialized = true;
+  }
+
+public:
+  /// Erases the output.
+  virtual ~OutputFile();
+
+  OutputFile(OutputFile &&O) = delete;
+  OutputFile &operator=(OutputFile &&O) = delete;
+
+protected:
+  explicit OutputFile(StringRef Path) : Path(Path.str()) {}
+
+private:
+  /// Output path.
+  std::string Path;
+
+  /// Tracks whether the output is still open, before one of \a erase() or \a
+  /// close() is called.
+  bool IsOpen = true;
+
+  /// Track whether this has been initialized.
+  bool IsStreamInitialized = false;
+
+  /// Content buffer if the output destination requests one. Behind a pointer
+  /// in case the output is moved, since the vector needs a stable address.
+  std::unique_ptr<SmallVector<char, 0>> Bytes;
+
+  // Destroyed ContentBuffer since it can reference it.
+  std::unique_ptr<raw_pwrite_stream> OS;
+};
+
+class OutputDirectory;
+
+/// Backend interface for \a OutputBackend. Its job is to generate \a
+/// OutputFileImpl given an \a OutputPath and \c OutputConfig.
+class OutputBackend : public RefCountedBase<OutputBackend> {
+  virtual void anchor();
+
+public:
+  Expected<std::unique_ptr<OutputFile>> createFile(const Twine &Path,
+                                                   OutputConfig Config = None);
+
+  /// Get the \a OutputDirectory for \p Path, which is an \a OutputBackend that
+  /// uses \c Path as the current working directory. \p Path does not need to
+  /// exist. This only fails when the call to \a resolveOutputPath() fails.
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  getDirectory(const Twine &Path) const;
+
+  /// Crete the \a OutputDirectory for \p Path, which is an \a OutputBackend
+  /// that uses \c Path as the current working directory.
+  ///
+  /// Not all backends have a concept of directories existing without files in
+  /// them.
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createDirectory(const Twine &Path, OutputConfig Config = None);
+
+  /// Create a unique file.
+  ///
+  /// Not all backends have access to an input filesystem.
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFile(const Twine &Model, OutputConfig Config = None);
+
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFile(const Twine &Prefix, StringRef Suffix,
+                   OutputConfig Config = None) {
+    return createUniqueFile(Prefix + "-%%%%%%%%" + Suffix, Config);
+  }
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectory(const Twine &Prefix, OutputConfig Config = None);
+
+  sys::path::Style getPathStyle() const { return PathStyle; }
+
+  /// A non-binding request to resolve \p Path. Output backends with a working
+  /// directory will typically make relative paths absolute here. For example,
+  /// see \a OutputDirectoryAdaptorBase::resolveOutputPathImpl().
+  ///
+  /// Called on all paths before forwarding to \a createFileImpl(),
+  /// \a createUniqueFileImpl(), \a createUniqueDirectoryImpl(), or
+  /// \a createDirectoryImpl().
+  virtual Expected<StringRef>
+  resolveOutputPath(const Twine &Path,
+                    SmallVectorImpl<char> &PathStorage) const;
+
+protected:
+  /// Create an \a OutputDirectory without checking if the directory exists.
+  virtual IntrusiveRefCntPtr<OutputDirectory>
+  getDirectoryImpl(StringRef ResolvedPath) const;
+
+  /// Create an output. Returning \c nullptr will cause the output to be
+  /// ignored.  Implementations should not call \a initialize(); that's done by
+  /// \a createFile().
+  ///
+  /// \return A valid \a OutputFile, \c nullptr, or an \a Error.
+  virtual Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef ResolvedPath, OutputConfig Config) = 0;
+
+  virtual Expected<std::unique_ptr<OutputFile>>
+  createUniqueFileImpl(StringRef ResolvedModel, OutputConfig Config) = 0;
+
+  /// Default implementation assumes that directory creation is a no-op, and
+  /// returns a just-constructed \a OutputDirectory with \p ResolvedPath.
+  virtual Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createDirectoryImpl(StringRef ResolvedPath, OutputConfig) {
+    return getDirectory(ResolvedPath);
+  }
+
+  virtual Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectoryImpl(StringRef ResolvedPrefix, OutputConfig Config) = 0;
+
+public:
+  OutputBackend() = delete;
+  explicit OutputBackend(sys::path::Style PathStyle) : PathStyle(PathStyle) {}
+
+  virtual ~OutputBackend() = default;
+
+private:
+  sys::path::Style PathStyle;
+};
+
+/// Helper class for creating proxies of another backend.
+class ProxyOutputBackend : public OutputBackend {
+protected:
+  Expected<StringRef>
+  resolveOutputPath(const Twine &Path,
+                    SmallVectorImpl<char> &PathStorage) const override {
+    return UnderlyingBackend->resolveOutputPath(Path, PathStorage);
+  }
+
+  Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef OutputPath, OutputConfig Config) override {
+    return UnderlyingBackend->createFile(OutputPath, Config);
+  }
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createDirectoryImpl(StringRef ResolvedPath, OutputConfig Config) override {
+    return UnderlyingBackend->createDirectory(ResolvedPath, Config);
+  }
+
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFileImpl(StringRef ResolvedModel, OutputConfig Config) override {
+    return UnderlyingBackend->createUniqueFile(ResolvedModel, Config);
+  }
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectoryImpl(StringRef ResolvedPrefix,
+                            OutputConfig Config) override {
+    return UnderlyingBackend->createUniqueDirectory(ResolvedPrefix, Config);
+  }
+
+  OutputBackend &getUnderlyingBackend() { return *UnderlyingBackend; }
+
+public:
+  ProxyOutputBackend(IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend)
+      : OutputBackend(UnderlyingBackend->getPathStyle()),
+        UnderlyingBackend(std::move(UnderlyingBackend)) {
+    assert(this->UnderlyingBackend && "Expected valid underlying backend");
+  }
+
+private:
+  IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend;
+};
+
+class OutputDirectoryAdaptorBase {
+protected:
+  /// If \p Path is relative and has a compatible root name with \a Directory,
+  /// prepend \a Directory to make it absolute. Otherwise, do nothing.
+  Expected<StringRef> resolveOutputPathImpl(const Twine &Path,
+                                            SmallVectorImpl<char> &PathStorage,
+                                            sys::path::Style PathStyle) const;
+
+public:
+  OutputDirectoryAdaptorBase(const Twine &Directory)
+      : Directory(Directory.str()) {}
+
+  StringRef getPath() const { return Directory; }
+
+private:
+  std::string Directory;
+};
+
+/// An adaptor to add a fixed working directory to an output backend.
+template <class BaseBackendT = OutputBackend>
+class OutputDirectoryAdaptor : public BaseBackendT, OutputDirectoryAdaptorBase {
+protected:
+  using OutputDirectoryAdaptorType = OutputDirectoryAdaptor;
+
+public:
+  Expected<StringRef>
+  resolveOutputPath(const Twine &Path,
+                    SmallVectorImpl<char> &PathStorage) const override {
+    return OutputDirectoryAdaptorBase::resolveOutputPathImpl(
+        Path, PathStorage, BaseBackendT::getPathStyle());
+  }
+
+  using OutputDirectoryAdaptorBase::getPath;
+
+  template <class... ArgsT>
+  OutputDirectoryAdaptor(const Twine &DirectoryPath, ArgsT &&... Args)
+      : BaseBackendT(std::forward<ArgsT>(Args)...),
+        OutputDirectoryAdaptorBase(DirectoryPath) {}
+};
+
+/// An output backend proxy with a fixed workign directory.
+class OutputDirectory : public OutputDirectoryAdaptor<ProxyOutputBackend> {
+  virtual void anchor();
+
+public:
+  /// Construct an output directory for a given backend. Does not check or
+  /// modify \p DirectoryPath, just assumes it's valid and absolute-enough.
+  ///
+  /// Most users will want \a OutputBackend::getDirectory(), which first
+  /// resolves the working directory, or \a OutputBackend::createDirectory(),
+  /// which also explicit requests creating it.
+  OutputDirectory(IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend,
+                  const Twine &DirectoryPath)
+      : OutputDirectoryAdaptorType(DirectoryPath,
+                                   std::move(UnderlyingBackend)) {}
+};
+
+/// A helper class for creating unique files and directories.
+class StableUniqueEntityHelper {
+public:
+  StringRef getNext(StringRef Model, SmallVectorImpl<char> &PathStorage);
+
+  Expected<std::unique_ptr<OutputFile>>
+  createStableUniqueFile(OutputBackend &Backend, StringRef Model,
+                         OutputConfig Config);
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createStableUniqueDirectory(OutputBackend &Backend, StringRef Model,
+                              OutputConfig Config);
+
+private:
+  StringMap<unsigned> Models;
+};
+
+/// An adaptor to create a default implementation of \a
+/// OutputBackend::createUniqueFileImpl() and \a
+/// OutputBackend::createUniqueDirectoryImpl().
+template <class BaseBackendT = OutputBackend>
+class StableUniqueEntityAdaptor : public BaseBackendT,
+                                  StableUniqueEntityHelper {
+protected:
+  using StableUniqueEntityAdaptorType = StableUniqueEntityAdaptor;
+
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFileImpl(StringRef Model, OutputConfig Config) override {
+    return this->createStableUniqueFile(*this, Model, Config);
+  }
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectoryImpl(StringRef Model, OutputConfig Config) override {
+    return this->createStableUniqueDirectory(*this, Model, Config);
+  }
+
+public:
+  template <class... ArgsT>
+  StableUniqueEntityAdaptor(ArgsT &&... Args)
+      : BaseBackendT(std::forward<ArgsT>(Args)...) {}
+};
+
+/// Interface for managing the destination of an \a OutputFile. Most users only
+/// need to deal with \a OutputFile.
+///
+/// \a OutputFileImpl's lifetime is expected to follow one of the following
+/// "good" paths after construction:
+/// - \a takeStream() is called and returns a valid stream. The caller writes
+///   content to the stream, destructs it, and then calls \a
+///   storeStreamedContent() is to store the content.
+/// - \a takeStream() is called and returns \c nullptr. The caller collects the
+///   content and calls \a storeContent() to store it.
+/// - \a storeContent() is called without first calling \a takeStream(), as the
+///   caller wants to pass in the completed content as a whole instead of
+///   streaming.
+///
+/// If the destination is destructed before calling \a storeStreamedContent()
+/// and \a storeContent(), this output will be cancelled and temporaries
+/// cleaned up.
+///
+/// \a storeContent() is designed to allow output destinations to be chained,
+/// passing content between them. \a ContentBuffer helps to manage the lifetime
+/// of the content, copying data and constructing memory buffers only as
+/// needed.
+class OutputFile::ContentBuffer {
+public:
+  StringRef getBytes() const { return Bytes; }
+
+  /// Whether the content is currently owned by this utility.
+  bool ownsContent() const { return Vector || OwnedBuffer; }
+
+  /// Returns a valid \a MemoryBuffer. If \a ownsContent() is false,
+  /// this buffer is a reference constructed on the fly using \a
+  /// MemoryBuffer::getMemBuffer().
+  ///
+  /// \post \b ownsContent() is false.
+  std::unique_ptr<MemoryBuffer> takeBuffer(StringRef Identifier);
+
+  /// Returns a valid \a MemoryBuffer that owns its bytes, or \c
+  /// nullptr if \a ownsContent() is \c false.
+  ///
+  /// \post \b ownsContent() is false.
+  std::unique_ptr<MemoryBuffer> takeOwnedBufferOrNull(StringRef Identifier);
+
+  /// Returns a valid \a MemoryBuffer that owns its bytes, or calls
+  /// MemoryBuffer::getMemBufferCopy() if \a ownsContent() is \c false.
+  ///
+  /// \post \b ownsContent() is false.
+  std::unique_ptr<MemoryBuffer> takeOwnedBufferOrCopy(StringRef Identifier);
+
+  /// Construct a reference to content owned by someone else.
+  ///
+  /// \post \b ownsContent() is false.
+  ContentBuffer(StringRef Bytes) : Bytes(Bytes) {
+    assert(!this->Bytes.end()[0] && "Requires null terminator");
+  }
+
+  /// Construct a buffer named \p Identifier from \p Vector. This buffer is
+  /// created lazily on the first call to \a takeBuffer() and friends using
+  /// \a SmallVectorMemoryBuffer.
+  ///
+  /// \post \b ownsContent() is true, unless \c Vector.empty().
+  /// \post \a getBytes() returns a range with the memory from \p Vector,
+  /// unless \p Vector was empty or in small mode.
+  ContentBuffer(SmallVectorImpl<char> &&Vector) : Vector(std::move(Vector)) {
+    finishConstructingFromVector();
+    assert(!Bytes.end()[0] && "Requires null terminator");
+  }
+
+  /// Store \p Buffer as the content, returned by the first call to \a
+  /// takeBuffer() and friends.
+  ///
+  /// \pre \p Buffer is null-terminated.
+  /// \post \b ownsContent() is true.
+  ContentBuffer(std::unique_ptr<MemoryBuffer> Buffer)
+      : Bytes(Buffer->getBuffer()), OwnedBuffer(std::move(Buffer)) {
+    assert(!Bytes.end()[0] && "Requires null terminator");
+  }
+
+  ContentBuffer(ContentBuffer &&) = default;
+  ContentBuffer &operator=(ContentBuffer &&) = default;
+
+private:
+  ContentBuffer() = delete;
+  ContentBuffer(const ContentBuffer &&) = delete;
+  ContentBuffer &operator=(const ContentBuffer &&) = delete;
+
+  /// Main body of constructor when initializing \a Vector.
+  void finishConstructingFromVector();
+
+  /// Reference to the bytes. Must be null-terminated.
+  StringRef Bytes;
+
+  /// Owned content stored in a vector.
+  Optional<SmallVector<char, 0>> Vector;
+
+  /// Owned content stored in a memory buffer.
+  std::unique_ptr<MemoryBuffer> OwnedBuffer;
+};
+
+/// Base class for OutputBackend errors.
+class OutputError : public ErrorInfo<OutputError> {
+  void anchor() override;
+
+public:
+  StringRef getOutputPath() const { return OutputPath; }
+  std::error_code getErrorCode() const { return EC; }
+
+  std::error_code convertToErrorCode() const override { return getErrorCode(); }
+
+  // Used by ErrorInfo::classID.
+  static char ID;
+
+protected:
+  OutputError(StringRef OutputPath, std::error_code EC)
+      : OutputPath(OutputPath), EC(EC) {
+    assert(EC && "Cannot create OutputError from success EC");
+  }
+
+private:
+  std::string OutputPath;
+  std::error_code EC;
+};
+
+/// The output already exists in filesystem and it cannot be overwritten.
+class CannotOverwriteExistingOutputError final
+    : public ErrorInfo<CannotOverwriteExistingOutputError, OutputError> {
+  friend Error createCannotOverwriteExistingOutputError(StringRef OutputPath);
+
+  void anchor() override;
+
+public:
+  void log(raw_ostream &OS) const override {
+    OS << "'" << getOutputPath() << "' already exists in-memory";
+  }
+
+  // Used by ErrorInfo::classID.
+  static char ID;
+
+private:
+  CannotOverwriteExistingOutputError(StringRef OutputPath)
+      : ErrorInfo<CannotOverwriteExistingOutputError, OutputError>(
+            OutputPath, std::make_error_code(std::errc::file_exists)) {}
+};
+
+inline Error createCannotOverwriteExistingOutputError(StringRef OutputPath) {
+  return Error(std::unique_ptr<CannotOverwriteExistingOutputError>(
+      new CannotOverwriteExistingOutputError(OutputPath)));
+}
+
+/// A temporary file could not be renamed to the final output on disk.
+class OnDiskOutputRenameTempError final
+    : public ErrorInfo<OnDiskOutputRenameTempError, OutputError> {
+  friend Error createOnDiskOutputRenameTempError(StringRef TempPath,
+                                                 StringRef OutputPath,
+                                                 std::error_code EC);
+  void anchor() override;
+
+public:
+  void log(raw_ostream &OS) const override {
+    assert(getErrorCode());
+    OS << "'" << TempPath << "' could not be renamed to ";
+    OS << "'" << getOutputPath() << "': ";
+    OS << getErrorCode().message();
+  }
+
+  StringRef getTempPath() const { return TempPath; }
+
+  // Used by ErrorInfo::classID.
+  static char ID;
+
+private:
+  OnDiskOutputRenameTempError(StringRef TempPath, StringRef OutputPath,
+                              std::error_code EC)
+      : ErrorInfo<OnDiskOutputRenameTempError, OutputError>(OutputPath, EC),
+        TempPath(TempPath) {
+    assert(EC && "Cannot create OnDiskOutputRenameTempError from success EC");
+  }
+
+  std::string TempPath;
+};
+
+inline Error createOnDiskOutputRenameTempError(StringRef TempPath,
+                                               StringRef OutputPath,
+                                               std::error_code EC) {
+  return Error(std::unique_ptr<OnDiskOutputRenameTempError>(
+      new OnDiskOutputRenameTempError(TempPath, OutputPath, EC)));
+}
+
+class OnDiskOutputBackend : public OutputBackend {
+  void anchor() override;
+
+protected:
+  Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef ResolvedPath, OutputConfig Config) override;
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createDirectoryImpl(StringRef ResolvedPath, OutputConfig Config) override;
+
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFileImpl(StringRef ResolvedModel, OutputConfig Config) override;
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectoryImpl(StringRef ResolvedPrefix,
+                            OutputConfig Config) override;
+
+public:
+  /// Big enough that mmap won't use up too much address space.
+  static constexpr unsigned MinimumSizeToReturnWriteThroughBuffer = 4 * 4096;
+
+  /// On disk output settings.
+  struct OutputSettings {
+    /// Register output files to be deleted if a signal is received. Disabled
+    /// for outputs with \a OutputConfigFlag::NoCrashCleanup.
+    bool RemoveOnSignal = true;
+
+    /// Use stable entity names for \a createUniqueFileImpl() and \a
+    /// createUniqueDirectoryImpl().
+    bool StableUniqueEntities = false;
+    struct {
+      bool Use = false;
+
+      // If a write-through buffer is used, try to forward it. Disabled for
+      // outputs with \a OutputConfigFlag::Volatile.
+      bool Forward = true;
+    } WriteThrough;
+  };
+  OutputSettings &getSettings() { return Settings; }
+  const OutputSettings &getSettings() const { return Settings; }
+
+  /// Get a view of this backend that has stable unique entity names.
+  IntrusiveRefCntPtr<OutputBackend> createStableUniqueEntityView() {
+    return makeIntrusiveRefCnt<StableUniqueEntityAdaptor<ProxyOutputBackend>>(
+        this);
+  }
+
+  OnDiskOutputBackend() : OutputBackend(sys::path::Style::native) {}
+
+private:
+  OutputSettings Settings;
+};
+
+/// Create a backend that ignores all output.
+IntrusiveRefCntPtr<OutputBackend>
+makeNullOutputBackend(sys::path::Style PathStyle = sys::path::Style::native);
+
+/// Create a backend that mirrors content between \a Backend1 and \a
+/// Backend2.
+///
+/// Both backends are asked to create destinations for each output. \a Backend1
+/// receives the content before \a Backend2.
+IntrusiveRefCntPtr<OutputBackend>
+makeMirroringOutputBackend(IntrusiveRefCntPtr<OutputBackend> Backend1,
+                           IntrusiveRefCntPtr<OutputBackend> Backend2);
+
+/// A backend for storing outputs in an instance of \a InMemoryFileSystem.
+class InMemoryOutputBackend : public StableUniqueEntityAdaptor<> {
+  void anchor() override;
+
+protected:
+  Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef OutputPath, OutputConfig Config) override;
+
+  /// Get the installed in-memory filesystem, if any.
+  InMemoryFileSystem &getInMemoryFS() const { return *FS; }
+
+public:
+  struct OutputSettings {
+    bool FailIfExists = false;
+    bool CopyUnownedBuffers = false;
+  };
+  OutputSettings &getSettings() { return Settings; }
+  const OutputSettings &getSettings() const { return Settings; }
+
+  InMemoryOutputBackend(IntrusiveRefCntPtr<InMemoryFileSystem> FS,
+                        sys::path::Style PathStyle = sys::path::Style::native)
+      : StableUniqueEntityAdaptorType(PathStyle), FS(std::move(FS)) {}
+
+private:
+  OutputSettings Settings;
+
+  /// In-memory filesystem for writing outputs to.
+  IntrusiveRefCntPtr<InMemoryFileSystem> FS;
+};
+
+/// Create an adaptor backend that filters the outputs that written to the
+/// underlying backend. Outputs where \p Filter returns \c false will be
+/// ignored.
+IntrusiveRefCntPtr<OutputBackend> makeFilteringOutputBackend(
+    IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend,
+    unique_function<bool(StringRef, OutputConfig)> Filter);
+
+} // namespace vfs
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_OUTPUTBACKEND_H

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MemoryBufferRef.cpp
   MD5.cpp
   NativeFormatting.cpp
   OptimizedStructLayout.cpp
   Optional.cpp
+  OutputBackend.cpp
   Parallel.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
   RISCVAttributes.cpp
   RISCVAttributeParser.cpp
   ScaledNumber.cpp

llvm/lib/Support/OutputBackend.cpp

+//===- OutputBackend.cpp - Manage compiler outputs ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the OutputBackend interface.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/OutputBackend.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/SmallVectorMemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::vfs;
+
+void OutputFile::anchor() {}
+void OutputBackend::anchor() {}
+void OutputDirectory::anchor() {}
+void OnDiskOutputBackend::anchor() {}
+void InMemoryOutputBackend::anchor() {}
+
+void OutputError::anchor() {}
+char OutputError::ID = 0;
+
+void CannotOverwriteExistingOutputError::anchor() {}
+char CannotOverwriteExistingOutputError::ID = 0;
+
+void OnDiskOutputRenameTempError::anchor() {}
+char OnDiskOutputRenameTempError::ID = 0;
+
+OutputFile::~OutputFile() = default;
+
+std::unique_ptr<raw_pwrite_stream> OutputFile::createStreamForContentBuffer() {
+  Bytes = std::make_unique<SmallVector<char, 0>>();
+  return std::make_unique<raw_svector_ostream>(*Bytes);
+}
+
+Error OutputFile::close() {
+  assert(isOpen() && "Output already closed");
+
+  // Destruct the stream if we still own it.
+  OS = nullptr;
+  IsOpen = false;
+
+  // If there's no content buffer this is using a stream.
+  if (!Bytes)
+    return storeStreamedContent();
+
+  // If there's a content buffer, send it along.
+  OutputFile::ContentBuffer Buffer(std::move(*Bytes));
+  return storeContentBuffer(Buffer);
+}
+
+void OutputFile::ContentBuffer::finishConstructingFromVector() {
+  // If Vector is empty, we can't guarantee SmallVectorMemoryBuffer will keep
+  // pointer identity. But since there's no content, it's all moot; just
+  // construct a reference.
+  if (Vector->empty()) {
+    // Drop the vector and use a null-terminated string for the bytes.
+    Vector = None;
+    Bytes = "";
+    return;
+  }
+
+  // Null-terminate and set the bytes.
+  Vector->push_back(0);
+  Vector->pop_back();
+  Bytes = StringRef(Vector->begin(), Vector->size());
+}
+
+namespace {
+class RenamedMemoryBuffer : public llvm::MemoryBuffer {
+public:
+  StringRef getBufferIdentifier() const override { return Identifier; }
+  BufferKind getBufferKind() const override {
+    return UnderlyingMB->getBufferKind();
+  }
+
+  RenamedMemoryBuffer(std::unique_ptr<llvm::MemoryBuffer> UnderlyingMB,
+                      StringRef Identifier)
+      : Identifier(Identifier.str()), UnderlyingMB(std::move(UnderlyingMB)) {
+    init(this->UnderlyingMB->getBufferStart(),
+         this->UnderlyingMB->getBufferEnd(),
+         /*RequiresNullTerminator=*/true);
+  }
+
+private:
+  std::string Identifier;
+  std::unique_ptr<llvm::MemoryBuffer> UnderlyingMB;
+};
+} // namespace
+
+std::unique_ptr<MemoryBuffer>
+OutputFile::ContentBuffer::takeOwnedBufferOrNull(StringRef Identifier) {
+  if (OwnedBuffer) {
+    // Ensure the identifier is correct.
+    if (OwnedBuffer->getBufferIdentifier() == Identifier)
+      return std::move(OwnedBuffer);
+    return std::make_unique<RenamedMemoryBuffer>(std::move(OwnedBuffer),
+                                                 Identifier);
+  }
+
+  if (!Vector)
+    return nullptr;
+
+  bool IsEmpty = Vector->empty();
+  (void)IsEmpty;
+  auto VectorBuffer =
+      std::make_unique<SmallVectorMemoryBuffer>(std::move(*Vector), Identifier);
+  Vector = None;
+  assert(Bytes.begin() == VectorBuffer->getBufferStart());
+  assert(Bytes.end() == VectorBuffer->getBufferEnd());
+  return VectorBuffer;
+}
+
+std::unique_ptr<MemoryBuffer>
+OutputFile::ContentBuffer::takeBuffer(StringRef Identifier) {
+  if (std::unique_ptr<MemoryBuffer> B = takeOwnedBufferOrNull(Identifier))
+    return B;
+  return MemoryBuffer::getMemBuffer(Bytes, Identifier);
+}
+
+std::unique_ptr<MemoryBuffer>
+OutputFile::ContentBuffer::takeOwnedBufferOrCopy(StringRef Identifier) {
+  if (std::unique_ptr<MemoryBuffer> B = takeOwnedBufferOrNull(Identifier))
+    return B;
+  return MemoryBuffer::getMemBufferCopy(Bytes, Identifier);
+}
+
+static std::unique_ptr<OutputFile> makeNullOutput(StringRef Path) {
+  class NullOutput : public OutputFile {
+    std::unique_ptr<raw_pwrite_stream> takeOSImpl() override {
+      return std::make_unique<raw_null_ostream>();
+    }
+    Error storeStreamedContent() override { return Error::success(); }
+    Error storeContentBuffer(ContentBuffer &) override {
+      return Error::success();
+    }
+    bool isNull() const override { return true; }
+
+  public:
+    NullOutput(StringRef Path) : OutputFile(Path) {}
+  };
+  return std::make_unique<NullOutput>(Path);
+}
+
+Expected<StringRef>
+OutputBackend::resolveOutputPath(const Twine &Path,
+                                 SmallVectorImpl<char> &PathStorage) const {
+  return Path.toStringRef(PathStorage);
+}
+
+IntrusiveRefCntPtr<OutputDirectory>
+OutputBackend::getDirectoryImpl(StringRef ResolvedPath) const {
+  return makeIntrusiveRefCnt<OutputDirectory>(const_cast<OutputBackend *>(this),
+                                              ResolvedPath);
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+OutputBackend::getDirectory(const Twine &Path) const {
+  SmallString<128> Storage;
+  if (Expected<StringRef> E = resolveOutputPath(Path, Storage))
+    return getDirectoryImpl(*E);
+  else
+    return E.takeError();
+}
+
+Expected<std::unique_ptr<OutputFile>>
+OutputBackend::createFile(const Twine &Path, OutputConfig Config) {
+  SmallString<128> Storage;
+  if (Expected<StringRef> E = resolveOutputPath(Path, Storage))
+    return createFileImpl(*E, Config);
+  else
+    return E.takeError();
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+OutputBackend::createDirectory(const Twine &Path, OutputConfig Config) {
+  SmallString<128> Storage;
+  if (Expected<StringRef> E = resolveOutputPath(Path, Storage))
+    return createDirectoryImpl(*E, Config);
+  else
+    return E.takeError();
+}
+
+Expected<std::unique_ptr<OutputFile>>
+OutputBackend::createUniqueFile(const Twine &Model, OutputConfig Config) {
+  SmallString<128> Storage;
+  if (Expected<StringRef> E = resolveOutputPath(Model, Storage))
+    return createUniqueFileImpl(*E, Config);
+  else
+    return E.takeError();
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+OutputBackend::createUniqueDirectory(const Twine &Model, OutputConfig Config) {
+  SmallString<128> Storage;
+  if (Expected<StringRef> E = resolveOutputPath(Model, Storage))
+    return createUniqueDirectoryImpl(*E, Config);
+  else
+    return E.takeError();
+}
+
+Expected<StringRef> OutputDirectoryAdaptorBase::resolveOutputPathImpl(
+    const Twine &PathTwine, SmallVectorImpl<char> &PathStorage,
+    sys::path::Style PathStyle) const {
+  StringRef Path = PathTwine.toStringRef(PathStorage);
+  if (sys::path::is_absolute(Path, PathStyle))
+    return Path;
+
+  // Return Path as-is if it has a root-name and it doesn't match
+  // Directory's root name, indicating that Directory and Path are on different
+  // drives.
+  //
+  // Note: This is intentionally asymmetric: a Directory without a root name
+  // is not prepended if Path has a root name.
+  StringRef PathRootName = sys::path::root_name(Path, PathStyle);
+  if (!PathRootName.empty() &&
+      PathRootName != sys::path::root_name(Directory, PathStyle))
+    return Path;
+
+  // Root names match. Make the path absolute.
+  SmallString<128> ResolvedPath = StringRef(Directory);
+  sys::path::append(ResolvedPath, PathStyle, Path);
+  ResolvedPath.swap(PathStorage);
+  return StringRef(PathStorage.begin(), PathStorage.size());
+}
+
+StringRef
+StableUniqueEntityHelper::getNext(StringRef Model,
+                                  SmallVectorImpl<char> &PathStorage) {
+  unsigned N = Models[Model]++;
+
+  // Replace '%' with chars representing N in hex.
+  PathStorage.assign(Model.begin(), Model.end());
+  for (auto I = PathStorage.rbegin(), E = PathStorage.rend(); I != E; ++I) {
+    if (*I != '%')
+      continue;
+    *I = "0123456789abcdef"[N & 15];
+    N >>= 4;
+  }
+
+  return StringRef(PathStorage.begin(), PathStorage.size());
+}
+
+template <class T>
+static Expected<T> createStableUniqueEntity(
+    StringRef Model, OutputConfig Config,
+    llvm::function_ref<StringRef(StringRef, SmallVectorImpl<char> &)> GetNext,
+    llvm::function_ref<Expected<T>(StringRef, OutputConfig)> CreateEntity) {
+  // Turn off overwriting and try models one at a time.
+  Config.set(OutputConfigFlag::NoOverwrite);
+  int NumTries = 0;
+  SmallString<128> PathStorage;
+  for (;;) {
+    PathStorage.clear();
+    StringRef Path = GetNext(Model, PathStorage);
+    auto ExpectedEntity = CreateEntity(Path, Config);
+    if (ExpectedEntity)
+      return std::move(*ExpectedEntity);
+
+    Error E = ExpectedEntity.takeError();
+    if (++NumTries >= 128)
+      return std::move(E);
+
+    // FIXME: Return E if it can't indicate a failure to clobber an existing
+    // entity; otherwise consume it and contintue.
+    //
+    // For OnDisk, we'd get:
+    // - errc::file_exists in typical cases
+    // - errc::permission_denied on Windows when marked for deletion
+    //
+    // But maybe we should rely on the backend being more clear.
+  }
+}
+
+Expected<std::unique_ptr<OutputFile>>
+StableUniqueEntityHelper::createStableUniqueFile(OutputBackend &Backend,
+                                                 StringRef Model,
+                                                 OutputConfig Config) {
+  return createStableUniqueEntity<std::unique_ptr<OutputFile>>(
+      Model, Config,
+      [this](StringRef Model, SmallVectorImpl<char> &PathStorage) {
+        return getNext(Model, PathStorage);
+      },
+      [&Backend](StringRef Path, OutputConfig Config) {
+        return Backend.createFile(Path, Config);
+      });
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+StableUniqueEntityHelper::createStableUniqueDirectory(OutputBackend &Backend,
+                                                      StringRef Model,
+                                                      OutputConfig Config) {
+  return createStableUniqueEntity<IntrusiveRefCntPtr<OutputDirectory>>(
+      Model, Config,
+      [this](StringRef Model, SmallVectorImpl<char> &PathStorage) {
+        return getNext(Model, PathStorage);
+      },
+      [&Backend](StringRef Path, OutputConfig Config) {
+        return Backend.createDirectory(Path, Config);
+      });
+}
+
+namespace {
+class NullOutputBackend : public StableUniqueEntityAdaptor<> {
+public:
+  Expected<std::unique_ptr<OutputFile>> createFileImpl(StringRef Path,
+                                                       OutputConfig) override {
+    return makeNullOutput(Path);
+  }
+
+  explicit NullOutputBackend(sys::path::Style PathStyle)
+      : StableUniqueEntityAdaptorType(PathStyle) {}
+};
+} // anonymous namespace
+
+IntrusiveRefCntPtr<OutputBackend>
+llvm::vfs::makeNullOutputBackend(sys::path::Style PathStyle) {
+  return makeIntrusiveRefCnt<NullOutputBackend>(PathStyle);
+}
+
+namespace {
+class OnDiskOutputFile : public OutputFile {
+public:
+  /// Open a file on-disk for writing to \a OutputPath.
+  ///
+  /// This calls \a initializeFD() to initialize \a FD (see that
+  /// documentation for more detail) and \a UseWriteThroughBuffer. Unless \a
+  /// UseWriteThroughBuffer was determined to be \c true, this function will
+  /// then initialize \a OS with a valid stream.
+  Error initializeFile();
+
+  /// Erases the file if it hasn't be closed. If \a TempFile is set, erases it;
+  /// otherwise, erases \a OutputPath.
+  ~OnDiskOutputFile() override;
+
+  /// Take an open output stream.
+  std::unique_ptr<raw_pwrite_stream> takeOSImpl() override;
+
+  Error storeStreamedContent() override { return closeFile(nullptr); }
+
+  Error storeContentBuffer(ContentBuffer &Content) override {
+    return closeFile(&Content);
+  }
+
+private:
+  using CheckingContentConsumerType =
+      function_ref<Error(Optional<ContentBuffer>)>;
+
+  /// Close a file after successfully collecting the output.
+  ///
+  /// The output content must have already been written somewhere, but
+  /// exactly where depends on the configuration.
+  ///
+  /// - If \a WriteThroughMemoryBuffer is \c true, the output will be in \a
+  ///   Content and \a FD has an open file descriptor. In that case, the file
+  ///   will be completed by opening \a WriteThroughMemoryBuffer and
+  ///   calling \a std::memcpy().
+  /// - Else if the output is in \a Content, it will be written to \a OS,
+  ///   which should be an already-open file stream, and the content will be
+  ///   written there and the stream destroyed to flush it.
+  /// - Else the content should already be in the file.
+  ///
+  /// Once the content is on-disk, if \a TempPath is set, this calls \a
+  /// sys::rename() to move the file to \a OutputPath.
+  ///
+  /// Returns a file-backed MemoryBuffer when the file was written using a
+  /// write-through memory buffer, unless it won't be null-terminated or it's
+  /// too small. Otherwise, when there's no error, returns \c nullptr.
+  Error closeFile(ContentBuffer *MaybeContent);
+
+  Expected<std::unique_ptr<sys::fs::mapped_file_region>>
+  openMappedFile(size_t Size);
+
+  std::unique_ptr<llvm::MemoryBuffer> convertMappedFileToBuffer(
+      std::unique_ptr<sys::fs::mapped_file_region> Mapping);
+
+  /// Attempt to open a temporary file for \a OutputPath.
+  ///
+  /// This tries to open a uniquely-named temporary file for \a OutputPath,
+  /// possibly also creating any missing directories if \a
+  /// OnDiskOutputConfig::UseTemporaryCreateMissingDirectories is set in \a
+  /// Config.
+  ///
+  /// \post FD and \a TempPath are initialized if this is successful.
+  std::error_code tryToCreateTemporary();
+
+  /// Open a file on-disk for writing to OutputPath.
+  ///
+  /// This opens a file for writing and assigns the file descriptor to \c FD.
+  /// Exactly how the file is opened depends on the \a OnDiskOutputConfig
+  /// settings in \p Config and (if the file exists) the type of file.
+  ///
+  /// - If \a getPath() is \c "-" (indicating stdin), this function returns
+  ///   \a Error::success() but has no effect.
+  /// - Unless \a OutputConfigFlag::NoAtomicWrite, a temporary file is opened
+  ///   first, to be renamed to \a getPath() when \a closeFile() is called.
+  ///   This is disabled if \a getPath() exists and \a
+  ///   sys::fs::is_regular_file() returns \c false (such as a named pipe). If
+  ///   \a tryToCreateTemporary() fails, this falls back to no-temp-file mode.
+  ///   (Even if using a temporary file, \a getPath() is checked for write
+  ///   permission.)
+  /// - \a OnDiskOutputConfig::RemoveFileOnSignal installs a signal handler
+  ///   to remove the opened file.
+  ///
+  /// This function also validates \c Settings.WriteThrough.Use based on the
+  /// output file type.
+  ///
+  /// \post FD is set unless \a OutputPath is \c "-" or on error.
+  /// \post TempPath is set if a temporary file was opened successfully.
+  Error initializeFD();
+
+  void initializeExistingFD();
+
+public:
+  OnDiskOutputFile(StringRef Path, OutputConfig Config,
+                   OnDiskOutputBackend::OutputSettings Settings)
+      : OutputFile(Path), Settings(Settings), Config(Config) {}
+
+  /// Construct from an already-open file descriptor.
+  OnDiskOutputFile(int FD, StringRef Path, OutputConfig Config,
+                   OnDiskOutputBackend::OutputSettings Settings)
+      : OutputFile(Path), Settings(Settings), Config(Config), FD(FD) {
+    initializeExistingFD();
+  }
+
+private:
+  OnDiskOutputBackend::OutputSettings Settings;
+  OutputConfig Config;
+  std::unique_ptr<raw_fd_ostream> OS;
+  Optional<std::string> TempPath;
+  Optional<int> FD;
+};
+} // anonymous namespace
+
+std::error_code OnDiskOutputFile::tryToCreateTemporary() {
+  // Create a temporary file.
+  // Insert -%%%%%%%% before the extension (if any), and because some tools
+  // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
+  // artifacts, also append .tmp.
+  StringRef OutputExtension = sys::path::extension(getPath());
+  SmallString<128> TempPath =
+      StringRef(getPath()).drop_back(OutputExtension.size());
+  TempPath += "-%%%%%%%%";
+  TempPath += OutputExtension;
+  TempPath += ".tmp";
+
+  auto tryToCreateImpl = [&]() {
+    int NewFD;
+    if (std::error_code EC =
+            sys::fs::createUniqueFile(TempPath, NewFD, TempPath))
+      return EC;
+    if (!Config.test(OutputConfigFlag::NoCrashCleanup))
+      sys::RemoveFileOnSignal(TempPath);
+    this->TempPath = TempPath.str().str();
+    FD = NewFD;
+    return std::error_code();
+  };
+
+  // Try to create the temporary.
+  std::error_code EC = tryToCreateImpl();
+  if (!EC)
+    return std::error_code();
+
+  if (EC != std::errc::no_such_file_or_directory ||
+      Config.test(OutputConfigFlag::NoImplyCreateDirectories))
+    return EC;
+
+  // Create parent directories and try again.
+  StringRef ParentPath = sys::path::parent_path(getPath());
+  if ((EC = sys::fs::create_directories(ParentPath)))
+    return EC;
+  return tryToCreateImpl();
+}
+
+Error OnDiskOutputFile::initializeFD() {
+  // Disable temporary file for stdout (and return early since we won't use a
+  // file descriptor directly).
+  if (getPath() == "-") {
+    Settings.WriteThrough.Use = false;
+    return Error::success();
+  }
+
+  // Function to check and update whether to use a write-through buffer.
+  bool CheckedStatusForWriteThrough = false;
+  auto checkStatusForWriteThrough = [&](const sys::fs::file_status &Status) {
+    if (CheckedStatusForWriteThrough)
+      return;
+    sys::fs::file_type Type = Status.type();
+    if (Type != sys::fs::file_type::regular_file &&
+        Type != sys::fs::file_type::block_file)
+      Settings.WriteThrough.Use = false;
+    CheckedStatusForWriteThrough = true;
+  };
+
+  // Disable temporary file for other non-regular files, and if we get a status
+  // object, also check if we can write and disable write-through buffers if
+  // appropriate.
+  if (!Config.test(OutputConfigFlag::NoAtomicWrite)) {
+    sys::fs::file_status Status;
+    sys::fs::status(getPath(), Status);
+    if (sys::fs::exists(Status)) {
+      if (!sys::fs::is_regular_file(Status))
+        Config.set(OutputConfigFlag::NoAtomicWrite);
+
+      // Fail now if we can't write to the final destination.
+      if (!sys::fs::can_write(getPath()))
+        return errorCodeToError(
+            std::make_error_code(std::errc::operation_not_permitted));
+
+      checkStatusForWriteThrough(Status);
+    }
+  }
+
+  // If (still) using a temporary file, try to create it (and return success if
+  // that works).
+  if (!Config.test(OutputConfigFlag::NoAtomicWrite))
+    if (!tryToCreateTemporary())
+      return Error::success();
+
+  // Not using a temporary file. Open the final output file.
+  int NewFD;
+  if (auto EC = sys::fs::openFileForWrite(
+          getPath(), NewFD, sys::fs::CD_CreateAlways,
+          Config.test(OutputConfigFlag::Text) ? sys::fs::OF_Text
+                                              : sys::fs::OF_None))
+    return errorCodeToError(EC);
+  FD = NewFD;
+
+  // Check the status with the open FD to see whether a write-through buffer
+  // makes sense.
+  if (Settings.WriteThrough.Use && !CheckedStatusForWriteThrough) {
+    sys::fs::file_status Status;
+    sys::fs::status(NewFD, Status);
+    checkStatusForWriteThrough(Status);
+  }
+
+  if (!Config.test(OutputConfigFlag::NoCrashCleanup))
+    sys::RemoveFileOnSignal(getPath());
+  return Error::success();
+}
+
+void OnDiskOutputFile::initializeExistingFD() {
+  this->Config.set(OutputConfigFlag::NoAtomicWrite);
+  if (!Config.test(OutputConfigFlag::NoCrashCleanup))
+    sys::RemoveFileOnSignal(getPath());
+}
+
+Error OnDiskOutputFile::initializeFile() {
+  if (!FD)
+    if (Error E = initializeFD())
+      return E;
+
+  assert(FD || getPath() == "-");
+  if (Settings.WriteThrough.Use)
+    return Error::success();
+
+  // Open the raw_fd_ostream right away to free the file descriptor.
+  std::error_code EC;
+  OS = getPath() == "-"
+           ? std::make_unique<raw_fd_ostream>(getPath(), EC)
+           : std::make_unique<raw_fd_ostream>(*FD, /*shouldClose=*/true);
+  assert(!EC && "Unexpected error opening stdin");
+
+  return Error::success();
+}
+
+std::unique_ptr<raw_pwrite_stream> OnDiskOutputFile::takeOSImpl() {
+  if (Settings.WriteThrough.Use)
+    return createStreamForContentBuffer();
+
+  assert(OS && "Expected file to be initialized");
+
+  // Check whether we can get away with returning the stream directly. Note
+  // that we don't need seeking for Text files.
+  if (OS->supportsSeeking() || Config.test(OutputConfigFlag::Text))
+    return std::move(OS);
+
+  // Fall back on the content buffer.
+  return createStreamForContentBuffer();
+}
+
+std::unique_ptr<llvm::MemoryBuffer> OnDiskOutputFile::convertMappedFileToBuffer(
+    std::unique_ptr<sys::fs::mapped_file_region> Mapping) {
+  assert(Mapping->const_data()[Mapping->size()] == 0 &&
+         "Expected mmap region to be null-terminated");
+
+  class MappedMemoryBuffer : public llvm::MemoryBuffer {
+  public:
+    StringRef getBufferIdentifier() const override { return Path; }
+    BufferKind getBufferKind() const override { return MemoryBuffer_MMap; }
+
+    MappedMemoryBuffer(StringRef Path,
+                       std::unique_ptr<sys::fs::mapped_file_region> Mapping)
+        : Path(Path.str()), Mapping(std::move(Mapping)) {
+      const char *Data = this->Mapping->const_data();
+      init(Data, Data + this->Mapping->size(), /*RequiresNullTerminator=*/true);
+    }
+
+  private:
+    std::string Path;
+    std::unique_ptr<sys::fs::mapped_file_region> Mapping;
+  };
+  return std::make_unique<MappedMemoryBuffer>(getPath(), std::move(Mapping));
+}
+
+Expected<std::unique_ptr<sys::fs::mapped_file_region>>
+OnDiskOutputFile::openMappedFile(size_t Size) {
+  if (auto EC = sys::fs::resize_file_before_mapping_readwrite(*FD, Size))
+    return errorCodeToError(EC);
+
+  std::error_code EC;
+  auto Mapping = std::make_unique<sys::fs::mapped_file_region>(
+      sys::fs::convertFDToNativeFile(*FD),
+      sys::fs::mapped_file_region::readwrite, Size, 0, EC);
+  if (EC)
+    return errorCodeToError(EC);
+  return Mapping;
+}
+
+Error OnDiskOutputFile::closeFile(ContentBuffer *MaybeContent) {
+  Optional<StringRef> BufferedContent;
+  if (MaybeContent)
+    BufferedContent = MaybeContent->getBytes();
+  if (Settings.WriteThrough.Use) {
+    assert(FD && "Write-through buffer needs a file descriptor");
+    assert(!OS && "Expected no stream when using write-through buffer");
+    assert(BufferedContent && "Expected buffered content");
+    std::unique_ptr<sys::fs::mapped_file_region> Mapping;
+    if (auto ExpectedMapping = openMappedFile(BufferedContent->size()))
+      Mapping = std::move(*ExpectedMapping);
+    else
+      return ExpectedMapping.takeError();
+
+    std::memcpy(Mapping->data(), BufferedContent->begin(),
+                BufferedContent->size());
+
+    // Decide whether to return the file-backed buffer.  Skip it when it's too
+    // small (fragmenting memory) or page-aligned (missing a null-terminator).
+    static unsigned PageSize = sys::Process::getPageSizeEstimate();
+    if (MaybeContent && Settings.WriteThrough.Forward &&
+        BufferedContent->size() >=
+            OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer &&
+        (BufferedContent->size() & (PageSize - 1)) != 0) {
+      // Synchronize the mapping to disk.
+      Mapping->sync();
+
+      // Forward the buffer.
+      *MaybeContent =
+          ContentBuffer(convertMappedFileToBuffer(std::move(Mapping)));
+    }
+    // Else, Mapping to destroy itself.
+  } else if (OS) {
+    // Write out the content and close the stream.
+    assert(BufferedContent && "Need to write content to a stream");
+    OS->write(BufferedContent->begin(), BufferedContent->size());
+    OS = nullptr;
+  } else {
+    assert(!BufferedContent &&
+           "Content in memory with no way to write it to disk?");
+  }
+
+  // Return early if there's no temporary path.
+  if (!TempPath)
+    return Error::success();
+
+  // Move temporary to the final output path.
+  std::error_code EC = sys::fs::rename(*TempPath, getPath());
+  if (!EC)
+    return Error::success();
+  (void)sys::fs::remove(*TempPath);
+  return createOnDiskOutputRenameTempError(*TempPath, getPath(), EC);
+}
+
+OnDiskOutputFile::~OnDiskOutputFile() {
+  if (!isOpen())
+    return;
+
+  destroyOS();
+
+  // If there's no FD we haven't created a file.
+  if (!FD)
+    return;
+
+  // If there's a temporary file, that's the one to delete.
+  if (TempPath)
+    sys::fs::remove(*TempPath);
+  else
+    sys::fs::remove(getPath());
+}
+
+Expected<std::unique_ptr<OutputFile>>
+OnDiskOutputBackend::createFileImpl(StringRef ResolvedPath,
+                                    OutputConfig Config) {
+  auto File =
+      std::make_unique<OnDiskOutputFile>(ResolvedPath, Config, Settings);
+  if (Error E = File->initializeFile())
+    return std::move(E);
+  return File;
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+OnDiskOutputBackend::createDirectoryImpl(StringRef ResolvedPath,
+                                         OutputConfig Config) {
+  bool IgnoreExisting = !Config.test(OutputConfigFlag::NoOverwrite);
+  if (std::error_code EC =
+          Config.test(OutputConfigFlag::NoImplyCreateDirectories)
+              ? sys::fs::create_directory(ResolvedPath, IgnoreExisting)
+              : sys::fs::create_directories(ResolvedPath, IgnoreExisting))
+    return errorCodeToError(EC);
+  return getDirectoryImpl(ResolvedPath);
+}
+
+Expected<std::unique_ptr<OutputFile>>
+OnDiskOutputBackend::createUniqueFileImpl(StringRef ResolvedModel,
+                                          OutputConfig Config) {
+  SmallString<128> Path;
+  int FD = -1;
+  {
+    std::error_code EC = sys::fs::createUniqueFile(ResolvedModel, FD, Path);
+    if (!EC)
+      return std::make_unique<OnDiskOutputFile>(FD, Path, Config, Settings);
+
+    if (EC != std::errc::no_such_file_or_directory ||
+        Config.test(OutputConfigFlag::NoImplyCreateDirectories))
+      return errorCodeToError(EC);
+  }
+
+  // Create the parent path and try again.
+  if (std::error_code EC =
+          sys::fs::create_directories(sys::path::parent_path(ResolvedModel)))
+    return errorCodeToError(EC);
+  if (std::error_code EC = sys::fs::createUniqueFile(ResolvedModel, FD, Path))
+    return errorCodeToError(EC);
+  return std::make_unique<OnDiskOutputFile>(FD, Path, Config, Settings);
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+OnDiskOutputBackend::createUniqueDirectoryImpl(StringRef ResolvedPrefix,
+                                               OutputConfig Config) {
+  SmallString<128> Path;
+  {
+    std::error_code EC = sys::fs::createUniqueDirectory(ResolvedPrefix, Path);
+    if (!EC)
+      return getDirectoryImpl(Path);
+
+    if (EC != std::errc::no_such_file_or_directory ||
+        Config.test(OutputConfigFlag::NoImplyCreateDirectories))
+      return errorCodeToError(EC);
+  }
+
+  // Create the parent path and try again.
+  if (std::error_code EC =
+          sys::fs::create_directories(sys::path::parent_path(ResolvedPrefix)))
+    return errorCodeToError(EC);
+  if (std::error_code EC = sys::fs::createUniqueDirectory(ResolvedPrefix, Path))
+    return errorCodeToError(EC);
+  return getDirectoryImpl(Path);
+}
+
+namespace {
+class InMemoryOutputDestination : public OutputFile {
+public:
+  Error storeContentBuffer(ContentBuffer &Content) override;
+
+  InMemoryOutputDestination(StringRef Path,
+                            IntrusiveRefCntPtr<InMemoryFileSystem> FS,
+                            InMemoryOutputBackend::OutputSettings Settings)
+      : OutputFile(Path), FS(std::move(FS)), Settings(Settings) {}
+
+private:
+  IntrusiveRefCntPtr<InMemoryFileSystem> FS;
+  InMemoryOutputBackend::OutputSettings Settings;
+};
+} // anonymous namespace
+
+Error InMemoryOutputDestination::storeContentBuffer(ContentBuffer &Content) {
+  assert(Content.getBytes().end()[0] == 0 && "Expected null-terminated buffer");
+
+  // Check the content of any existing buffer. We cannot rely on the logic in
+  // InMemoryFileSystem::addFile, since Content and/or other backends could
+  // have dangling references to the buffer and addFile will destroy it if it
+  // can't be added.
+  //
+  // FIXME: Add an API to InMemoryFileSystem to get out an
+  // Optional<MemoryBufferRef> to avoid an unnecessary malloc of MemoryBuffer.
+  if (ErrorOr<std::unique_ptr<MemoryBuffer>> ExistingBuffer =
+          FS->getBufferForFile(getPath()))
+    return ExistingBuffer->get()->getBuffer() == Content.getBytes()
+               ? Error::success()
+               : createCannotOverwriteExistingOutputError(getPath());
+
+  std::unique_ptr<MemoryBuffer> Buffer =
+      Settings.CopyUnownedBuffers ? Content.takeOwnedBufferOrCopy(getPath())
+                                  : Content.takeBuffer(getPath());
+  bool WasAdded = FS->addFile(getPath(), 0, std::move(Buffer));
+  assert(WasAdded && "Already checked this would work; what changed?");
+  return Error::success();
+}
+
+Expected<std::unique_ptr<OutputFile>>
+InMemoryOutputBackend::createFileImpl(StringRef ResolvedPath,
+                                      OutputConfig Config) {
+  if ((Settings.FailIfExists || Config.test(OutputConfigFlag::NoOverwrite)) &&
+      FS->exists(ResolvedPath))
+    return createCannotOverwriteExistingOutputError(ResolvedPath);
+
+  // FIXME: OutputConfigFlag::NoOverwrite also needs to check for in-flight
+  // outputs.
+
+  return std::make_unique<InMemoryOutputDestination>(ResolvedPath, FS,
+                                                     Settings);
+}
+
+namespace {
+class MirroringOutputBackend : public OutputBackend {
+  class File;
+
+public:
+  Expected<StringRef>
+  resolveOutputPath(const Twine &Path,
+                    SmallVectorImpl<char> &PathStorage) const override {
+    return Backend1->resolveOutputPath(Path, PathStorage);
+  }
+
+  Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef ResolvedPath, OutputConfig Config) override;
+
+  Expected<std::unique_ptr<OutputFile>>
+  createUniqueFileImpl(StringRef ResolvedModel, OutputConfig Config) override;
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createDirectoryImpl(StringRef ResolvedPath, OutputConfig Config) override;
+
+  Expected<IntrusiveRefCntPtr<OutputDirectory>>
+  createUniqueDirectoryImpl(StringRef ResolvedModel,
+                            OutputConfig Config) override;
+
+  MirroringOutputBackend(IntrusiveRefCntPtr<OutputBackend> Backend1,
+                         IntrusiveRefCntPtr<OutputBackend> Backend2)
+      : OutputBackend(Backend1->getPathStyle()), Backend1(std::move(Backend1)),
+        Backend2(std::move(Backend2)) {
+    assert(this->Backend2->getPathStyle() == getPathStyle() &&
+           "Path style needs to match between mirrored backends");
+  }
+
+private:
+  IntrusiveRefCntPtr<OutputBackend> Backend1;
+  IntrusiveRefCntPtr<OutputBackend> Backend2;
+};
+} // anonymous namespace
+
+class MirroringOutputBackend::File : public OutputFile {
+  Error storeContentBuffer(ContentBuffer &Content) override {
+    if (Error E = storeContentBufferIn(Content, *File1))
+      return E;
+    return File2->storeContentBufferIn(Content, *File2);
+  }
+
+public:
+  File(std::unique_ptr<OutputFile> File1, std::unique_ptr<OutputFile> File2)
+      : OutputFile(File1->getPath()), File1(std::move(File1)),
+        File2(std::move(File2)) {}
+
+  static std::unique_ptr<OutputFile> create(std::unique_ptr<OutputFile> File1,
+                                            std::unique_ptr<OutputFile> File2) {
+    if (isNull(*File1))
+      return File2;
+    if (isNull(*File2))
+      return File1;
+    return std::make_unique<File>(std::move(File1), std::move(File2));
+  }
+
+  std::unique_ptr<OutputFile> File1;
+  std::unique_ptr<OutputFile> File2;
+};
+
+IntrusiveRefCntPtr<OutputBackend> llvm::vfs::makeMirroringOutputBackend(
+    IntrusiveRefCntPtr<OutputBackend> Backend1,
+    IntrusiveRefCntPtr<OutputBackend> Backend2) {
+  return std::make_unique<MirroringOutputBackend>(std::move(Backend1),
+                                                  std::move(Backend2));
+}
+
+Expected<std::unique_ptr<OutputFile>>
+MirroringOutputBackend::createFileImpl(StringRef ResolvedPath,
+                                       OutputConfig Config) {
+  // Create destinations for each backend.
+  SmallVector<std::unique_ptr<OutputFile>, 2> Files;
+  for (OutputBackend *B : {&*Backend1, &*Backend2}) {
+    Expected<std::unique_ptr<OutputFile>> File =
+        B->createFile(ResolvedPath, Config);
+    if (!File)
+      return File.takeError();
+    Files.push_back(std::move(*File));
+  }
+
+  return File::create(std::move(Files[0]), std::move(Files[1]));
+}
+
+Expected<std::unique_ptr<OutputFile>>
+MirroringOutputBackend::createUniqueFileImpl(StringRef ResolvedModel,
+                                             OutputConfig Config) {
+  // Create a unique file in the first backend.
+  Expected<std::unique_ptr<OutputFile>> ExpectedFile =
+      Backend1->createUniqueFile(ResolvedModel, Config);
+  if (!ExpectedFile)
+    return ExpectedFile.takeError();
+  std::unique_ptr<OutputFile> File = std::move(*ExpectedFile);
+
+  // Create the same file in the second backend.
+  Config.set(OutputConfigFlag::NoOverwrite);
+  ExpectedFile = Backend2->createFile(File->getPath(), Config);
+  if (!ExpectedFile)
+    return ExpectedFile.takeError();
+  return File::create(std::move(File), std::move(*ExpectedFile));
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+MirroringOutputBackend::createDirectoryImpl(StringRef ResolvedPath,
+                                            OutputConfig Config) {
+  // Create directories for each backend in order to check for errors.
+  for (OutputBackend *B : {&*Backend1, &*Backend2}) {
+    Expected<IntrusiveRefCntPtr<OutputDirectory>> Dir =
+        B->createDirectory(ResolvedPath, Config);
+    if (!Dir)
+      return Dir.takeError();
+  }
+
+  // Return an output directory for this backend.
+  return makeIntrusiveRefCnt<OutputDirectory>(this, ResolvedPath);
+}
+
+Expected<IntrusiveRefCntPtr<OutputDirectory>>
+MirroringOutputBackend::createUniqueDirectoryImpl(StringRef ResolvedModel,
+                                                  OutputConfig Config) {
+  // Create a unique directory in the first backend.
+  Expected<IntrusiveRefCntPtr<OutputDirectory>> ExpectedDir =
+      Backend1->createUniqueDirectory(ResolvedModel, Config);
+  if (!ExpectedDir)
+    return ExpectedDir.takeError();
+  IntrusiveRefCntPtr<OutputDirectory> Dir = std::move(*ExpectedDir);
+
+  // Create the same directory in the second backend.
+  Config.set(OutputConfigFlag::NoOverwrite);
+  ExpectedDir = Backend2->createDirectory(Dir->getPath(), Config);
+  if (!ExpectedDir)
+    return ExpectedDir.takeError();
+  return makeIntrusiveRefCnt<OutputDirectory>(this, Dir->getPath());
+}
+
+namespace {
+class FilteringOutputBackend : public ProxyOutputBackend {
+public:
+  Expected<std::unique_ptr<OutputFile>>
+  createFileImpl(StringRef ResolvedPath, OutputConfig Config) override {
+    if (!Filter(ResolvedPath, Config))
+      return makeNullOutput(ResolvedPath);
+    return ProxyOutputBackend::createFileImpl(ResolvedPath, Config);
+  }
+
+  using FilterType = unique_function<bool(StringRef, OutputConfig)>;
+  FilteringOutputBackend(IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend,
+                         FilterType Filter)
+      : ProxyOutputBackend(std::move(UnderlyingBackend)),
+        Filter(std::move(Filter)) {}
+
+private:
+  FilterType Filter;
+};
+} // anonymous namespace
+
+IntrusiveRefCntPtr<OutputBackend> llvm::vfs::makeFilteringOutputBackend(
+    IntrusiveRefCntPtr<OutputBackend> UnderlyingBackend,
+    FilteringOutputBackend::FilterType Filter) {
+  return std::make_unique<FilteringOutputBackend>(std::move(UnderlyingBackend),
+                                                  std::move(Filter));
+}

llvm/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   MD5Test.cpp
   ManagedStatic.cpp
   MathExtrasTest.cpp
   MemoryBufferRefTest.cpp
   MemoryBufferTest.cpp
   MemoryTest.cpp
   NativeFormatTests.cpp
   OptimizedStructLayoutTest.cpp
+  OutputConfigTest.cpp
+  OutputBackendTest.cpp
   ParallelTest.cpp
   Path.cpp
   ProcessTest.cpp
   ProgramTest.cpp
   RegexTest.cpp
   ReverseIterationTest.cpp
   ReplaceFileTest.cpp
   RISCVAttributeParserTest.cpp

llvm/unittests/Support/OutputBackendTest.cpp

+//===- unittests/Support/OutputBackendTest.cpp - OutputBackend tests ------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/OutputBackend.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::vfs;
+
+namespace {
+
+using ContentBuffer = OutputFile::ContentBuffer;
+
+TEST(OutputFileContentBufferTest, takeBuffer) {
+  StringRef S = "data";
+  ContentBuffer Content = S;
+  EXPECT_FALSE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(S.begin(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+
+  // The buffer should be a reference to the original data, and Content should
+  // still have it too.
+  EXPECT_EQ(S.begin(), Taken->getBufferStart());
+  EXPECT_EQ(S.begin(), Content.getBytes().begin());
+}
+
+TEST(OutputFileContentBufferTest, takeBufferVector) {
+  SmallString<0> V = StringRef("data");
+  StringRef R = V;
+
+  ContentBuffer Content = std::move(V);
+  EXPECT_TRUE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.begin(), Content.getBytes().begin());
+  EXPECT_NE(V.begin(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.begin(), Taken->getBufferStart());
+
+  // Content should still have a reference to the data.
+  EXPECT_FALSE(Content.ownsContent());
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+}
+
+TEST(OutputFileContentBufferTest, takeBufferVectorSmallStorage) {
+  // Something using small storage will have to move.
+  SmallString<128> V = StringRef("data");
+  ASSERT_EQ(128u, V.capacity());
+  StringRef R = V;
+
+  ContentBuffer Content = std::move(V);
+  EXPECT_TRUE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_NE(R.begin(), Content.getBytes().begin());
+}
+
+TEST(OutputFileContentBufferTest, takeBufferMemoryBuffer) {
+  std::unique_ptr<MemoryBuffer> B = MemoryBuffer::getMemBuffer("data");
+  MemoryBufferRef R = *B;
+
+  ContentBuffer Content = std::move(B);
+  EXPECT_TRUE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.getBufferStart(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.getBufferStart(), Taken->getBufferStart());
+
+  // Content should still have a reference to the data.
+  EXPECT_FALSE(Content.ownsContent());
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+}
+
+TEST(OutputFileContentBufferTest, takeBufferMemoryBufferSameName) {
+  std::unique_ptr<MemoryBuffer> B = MemoryBuffer::getMemBuffer("data", "name");
+  MemoryBufferRef R = *B;
+
+  ContentBuffer Content = std::move(B);
+  EXPECT_TRUE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.getBufferStart(), Content.getBytes().begin());
+
+  // This exact buffer should be returned since the name matches.
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.getBufferStart(), Taken->getBufferStart());
+  EXPECT_EQ(R.getBufferIdentifier().begin(),
+            Taken->getBufferIdentifier().begin());
+}
+
+TEST(OutputFileContentBufferTest, takeBufferMemoryBufferWrongName) {
+  std::unique_ptr<MemoryBuffer> B = MemoryBuffer::getMemBuffer("data", "other");
+  MemoryBufferRef R = *B;
+
+  ContentBuffer Content = std::move(B);
+  EXPECT_TRUE(Content.ownsContent());
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.getBufferStart(), Content.getBytes().begin());
+
+  // Check that the name is updated.
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.getBufferStart(), Taken->getBufferStart());
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrNull) {
+  StringRef S = "data";
+  ContentBuffer Content = S;
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(S.begin(), Content.getBytes().begin());
+
+  // ContentBuffer doesn't own this.
+  EXPECT_FALSE(Content.takeOwnedBufferOrNull("name"));
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrNullVector) {
+  SmallString<0> V = StringRef("data");
+  StringRef R = V;
+
+  ContentBuffer Content = std::move(V);
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.begin(), Content.getBytes().begin());
+  EXPECT_NE(V.begin(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeOwnedBufferOrNull("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.begin(), Taken->getBufferStart());
+
+  // Content should still have a reference to the data.
+  EXPECT_FALSE(Content.ownsContent());
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+
+  // The next call should fail since it's no longer owned.
+  EXPECT_FALSE(Content.takeOwnedBufferOrNull("name"));
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrNullVectorEmpty) {
+  SmallString<0> V;
+
+  ContentBuffer Content = std::move(V);
+  EXPECT_EQ("", Content.getBytes());
+
+  // Check that ContentBuffer::takeOwnedBufferOrNull() fails for an empty
+  // vector.
+  EXPECT_FALSE(Content.ownsContent());
+  ASSERT_FALSE(Content.takeOwnedBufferOrNull("name"));
+
+  // ContentBuffer::takeBuffer() should still work.
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeBuffer("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrNullMemoryBuffer) {
+  std::unique_ptr<MemoryBuffer> B = MemoryBuffer::getMemBuffer("data");
+  MemoryBufferRef R = *B;
+
+  ContentBuffer Content = std::move(B);
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.getBufferStart(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeOwnedBufferOrNull("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.getBufferStart(), Taken->getBufferStart());
+
+  // Content should still have a reference to the data.
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+
+  // The next call should fail since it's no longer owned.
+  EXPECT_FALSE(Content.takeOwnedBufferOrNull("name"));
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrCopy) {
+  StringRef S = "data";
+  ContentBuffer Content = S;
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(S.begin(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeOwnedBufferOrCopy("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+
+  // We should have a copy, but Content should be unchanged.
+  EXPECT_NE(S.begin(), Taken->getBufferStart());
+  EXPECT_EQ(S.begin(), Content.getBytes().begin());
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrCopyVector) {
+  SmallString<0> V = StringRef("data");
+  StringRef R = V;
+
+  ContentBuffer Content = std::move(V);
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.begin(), Content.getBytes().begin());
+  EXPECT_NE(V.begin(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeOwnedBufferOrCopy("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+
+  // Content should still have a reference to the data, but it's no longer
+  // owned.
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+  EXPECT_FALSE(Content.takeOwnedBufferOrNull("name"));
+
+  // The next call should get a different (but equal) buffer.
+  std::unique_ptr<MemoryBuffer> Copy = Content.takeOwnedBufferOrCopy("name");
+  ASSERT_TRUE(Copy);
+  EXPECT_EQ("data", Copy->getBuffer());
+  EXPECT_EQ("name", Copy->getBufferIdentifier());
+  EXPECT_NE(Taken->getBufferStart(), Copy->getBufferStart());
+}
+
+TEST(OutputFileContentBufferTest, takeOwnedBufferOrCopyMemoryBuffer) {
+  std::unique_ptr<MemoryBuffer> B = MemoryBuffer::getMemBuffer("data");
+  MemoryBufferRef R = *B;
+
+  ContentBuffer Content = std::move(B);
+  EXPECT_EQ("data", Content.getBytes());
+  EXPECT_EQ(R.getBufferStart(), Content.getBytes().begin());
+
+  std::unique_ptr<MemoryBuffer> Taken = Content.takeOwnedBufferOrCopy("name");
+  ASSERT_TRUE(Taken);
+  EXPECT_EQ("data", Taken->getBuffer());
+  EXPECT_EQ("name", Taken->getBufferIdentifier());
+  EXPECT_EQ(R.getBufferStart(), Taken->getBufferStart());
+
+  // Content should still have a reference to the data.
+  EXPECT_EQ(Taken->getBuffer(), Content.getBytes());
+  EXPECT_EQ(Taken->getBufferStart(), Content.getBytes().begin());
+  EXPECT_EQ(Content.getBytes().begin(), Taken->getBufferStart());
+
+  // The next call should get a different (but equal) buffer.
+  std::unique_ptr<MemoryBuffer> Copy = Content.takeOwnedBufferOrCopy("name");
+  ASSERT_TRUE(Copy);
+  EXPECT_EQ("data", Copy->getBuffer());
+  EXPECT_EQ("name", Copy->getBufferIdentifier());
+  EXPECT_NE(Taken->getBufferStart(), Copy->getBufferStart());
+}
+
+struct OnDiskTempDirectory {
+  bool Created = false;
+  SmallString<128> Path;
+
+  OnDiskTempDirectory() = delete;
+  explicit OnDiskTempDirectory(StringRef Name) {
+    if (!sys::fs::createUniqueDirectory(Name, Path))
+      Created = true;
+  }
+  ~OnDiskTempDirectory() {
+    if (Created)
+      sys::fs::remove_directories(Path);
+  }
+};
+
+struct OnDiskFile {
+  const OnDiskTempDirectory &D;
+  SmallString<128> Path;
+  StringRef ParentPath;
+  StringRef Filename;
+  StringRef Stem;
+  StringRef Extension;
+  std::unique_ptr<MemoryBuffer> LastBuffer;
+
+  template <class... PathArgTypes>
+  OnDiskFile(const OnDiskTempDirectory &D, PathArgTypes &&... PathArgs) : D(D) {
+    assert(D.Created);
+    sys::path::append(Path, D.Path, std::forward<PathArgTypes>(PathArgs)...);
+    ParentPath = sys::path::parent_path(Path);
+    Filename = sys::path::filename(Path);
+    Stem = sys::path::stem(Filename);
+    Extension = sys::path::extension(Filename);
+  }
+
+  Optional<OnDiskFile> findTemp() const {
+    std::error_code EC;
+    for (sys::fs::directory_iterator I(ParentPath, EC), E; !EC && I != E;
+         I.increment(EC)) {
+      StringRef TempPath = I->path();
+      if (!TempPath.startswith(D.Path))
+        continue;
+
+      // Look for "<stem>-*.<extension>.tmp".
+      if (sys::path::extension(TempPath) != ".tmp")
+        continue;
+
+      // Drop the ".tmp" and check the extension and stem.
+      StringRef TempStem = sys::path::stem(TempPath);
+      if (sys::path::extension(TempStem) != Extension)
+        continue;
+      StringRef OriginalStem = sys::path::stem(TempStem);
+      if (!OriginalStem.startswith(Stem))
+        continue;
+      if (!OriginalStem.drop_front(Stem.size()).startswith("-"))
+        continue;
+
+      // Found it.
+      return OnDiskFile(D, TempPath.drop_front(D.Path.size() + 1));
+    }
+    return None;
+  }
+
+  Optional<sys::fs::UniqueID> getCurrentUniqueID() {
+    sys::fs::file_status Status;
+    sys::fs::status(Path, Status, /*follow=*/false);
+    if (!sys::fs::is_regular_file(Status))
+      return None;
+    return Status.getUniqueID();
+  }
+
+  bool hasUniqueID(sys::fs::UniqueID ID) {
+    auto CurrentID = getCurrentUniqueID();
+    if (!CurrentID)
+      return false;
+    return *CurrentID == ID;
+  }
+
+  Optional<StringRef> getCurrentContent() {
+    auto OnDiskOrErr = MemoryBuffer::getFile(Path);
+    if (!OnDiskOrErr)
+      return None;
+    LastBuffer = std::move(*OnDiskOrErr);
+    return LastBuffer->getBuffer();
+  }
+
+  bool equalsCurrentContent(StringRef Data) {
+    auto CurrentContent = getCurrentContent();
+    if (!CurrentContent)
+      return false;
+    return *CurrentContent == Data;
+  }
+
+  bool equalsCurrentContent(NoneType) { return getCurrentContent() == None; }
+};
+
+struct OutputBackendTest : public ::testing::Test {
+  Optional<OnDiskTempDirectory> D;
+
+  void TearDown() override { D = None; }
+
+  bool makeTempDirectory() {
+    D.emplace("OutputBackendTest.d");
+    return D->Created;
+  }
+
+  template <class T>
+  std::unique_ptr<T>
+  expectedToPointer(Expected<std::unique_ptr<T>> ExpectedPointer) {
+    if (ExpectedPointer)
+      return std::move(*ExpectedPointer);
+    consumeError(ExpectedPointer.takeError());
+    return nullptr;
+  }
+
+  template <class T>
+  IntrusiveRefCntPtr<T>
+  expectedToPointer(Expected<IntrusiveRefCntPtr<T>> ExpectedPointer) {
+    if (ExpectedPointer)
+      return std::move(*ExpectedPointer);
+    consumeError(ExpectedPointer.takeError());
+    return nullptr;
+  }
+
+  std::unique_ptr<MemoryBuffer> openBufferForRead(InMemoryFileSystem &FS,
+                                                  StringRef Path) {
+    if (auto FileOrErr = FS.openFileForRead(Path))
+      if (*FileOrErr)
+        if (auto BufferOrErr = (*FileOrErr)->getBuffer(Path))
+          if (*BufferOrErr)
+            return std::move(*BufferOrErr);
+    return nullptr;
+  }
+};
+
+TEST_F(OutputBackendTest, Null) {
+  auto Backend = makeNullOutputBackend();
+
+  // Create the output.
+  auto O = expectedToPointer(Backend->createFile("ignored.data"));
+  ASSERT_TRUE(O);
+  ASSERT_TRUE(O->getOS());
+
+  // Write some data into it and close the stream.
+  *O->takeOS() << "some data";
+
+  // Closing should have no effect.
+  EXPECT_FALSE(errorToBool(O->close()));
+}
+
+TEST_F(OutputBackendTest, NullErase) {
+  auto Backend = makeNullOutputBackend();
+
+  // Create the output.
+  auto O = expectedToPointer(Backend->createFile("ignored.data"));
+  ASSERT_TRUE(O);
+  ASSERT_TRUE(O->getOS());
+
+  // Write some data into it and close the stream.
+  *O->takeOS() << "some data";
+
+  // Erasing should have no effect.
+  O = nullptr;
+}
+
+TEST_F(OutputBackendTest, OnDisk) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  Backend->getSettings().WriteThrough.Use = false;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // File shouldn't exist, but the temporary should.
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+  Optional<OnDiskFile> Temp = File.findTemp();
+  ASSERT_TRUE(Temp);
+  Optional<sys::fs::UniqueID> TempID = Temp->getCurrentUniqueID();
+  ASSERT_TRUE(TempID);
+
+  // Write some data into it and flush.
+  *O->takeOS() << "some data";
+  EXPECT_TRUE(Temp->equalsCurrentContent("some data"));
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+
+  // Close and check again.
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(Temp->equalsCurrentContent(None));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+
+  // The temp file should have been moved.
+  EXPECT_TRUE(File.hasUniqueID(*TempID));
+}
+
+TEST_F(OutputBackendTest, OnDiskErase) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  Backend->getSettings().WriteThrough.Use = false;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // File shouldn't exist, but the temporary should.
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+  Optional<OnDiskFile> Temp = File.findTemp();
+  ASSERT_TRUE(Temp);
+
+  // Write some data into it and close the stream.
+  *O->takeOS() << "some data";
+
+  // Erase and check that the temp is gone.
+  O = nullptr;
+  EXPECT_TRUE(Temp->equalsCurrentContent(None));
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+}
+
+TEST_F(OutputBackendTest, OnDiskMissingDirectories) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "missing", "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // File shouldn't exist, but the temporary should.
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+  Optional<OnDiskFile> Temp = File.findTemp();
+  ASSERT_TRUE(Temp);
+  Optional<sys::fs::UniqueID> TempID = Temp->getCurrentUniqueID();
+  ASSERT_TRUE(TempID);
+
+  // Write some data into it and flush.
+  *O->takeOS() << "some data";
+  EXPECT_TRUE(Temp->equalsCurrentContent("some data"));
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+
+  // Close and check again.
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(Temp->equalsCurrentContent(None));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+
+  // The temp file should have been moved.
+  EXPECT_TRUE(File.hasUniqueID(*TempID));
+}
+
+TEST_F(OutputBackendTest, OnDiskNoImplyCreateDirectories) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "missing", "on-disk.data");
+
+  // Fail to create the missing directory.
+  auto Expected = Backend->createFile(
+      File.Path, {OutputConfigFlag::NoImplyCreateDirectories});
+  ASSERT_FALSE(Expected);
+  std::error_code EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::no_such_file_or_directory), EC.value());
+}
+
+TEST_F(OutputBackendTest, OnDiskNoAtomicWrite) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(
+      Backend->createFile(File.Path, {OutputConfigFlag::NoAtomicWrite}));
+  ASSERT_TRUE(O);
+
+  // File should exist with no temporary.
+  EXPECT_TRUE(File.equalsCurrentContent(""));
+  Optional<sys::fs::UniqueID> ID = File.getCurrentUniqueID();
+  ASSERT_TRUE(ID);
+  Optional<OnDiskFile> Temp = File.findTemp();
+  ASSERT_FALSE(Temp);
+
+  // Write some data into it and flush.
+  *O->takeOS() << "some data";
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+
+  // Close and check again.
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+  EXPECT_TRUE(File.hasUniqueID(*ID));
+}
+
+TEST_F(OutputBackendTest, OnDiskNoAtomicWriteErase) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(
+      Backend->createFile(File.Path, {OutputConfigFlag::NoAtomicWrite}));
+  ASSERT_TRUE(O);
+
+  // File should exist with no temporary.
+  EXPECT_TRUE(File.equalsCurrentContent(""));
+
+  // Write some data into it and flush.
+  *O->takeOS() << "some data";
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+
+  // Erase. Since NoAtomicWrite was used the file should now be gone.
+  O = nullptr;
+}
+
+TEST_F(OutputBackendTest, OnDiskWriteThroughUse) {
+  auto Backend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  Backend->getSettings().WriteThrough.Use = true;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // File shouldn't exist, but the temporary should.
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+  Optional<OnDiskFile> Temp = File.findTemp();
+  ASSERT_TRUE(Temp);
+  Optional<sys::fs::UniqueID> TempID = Temp->getCurrentUniqueID();
+  ASSERT_TRUE(TempID);
+
+  // Write some data into it and flush. Confirm it's not on disk because it's
+  // waiting to be written using a write-through buffer.
+  *O->takeOS() << "some data";
+  EXPECT_TRUE(Temp->equalsCurrentContent(""));
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+
+  // Close and check again.
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(Temp->equalsCurrentContent(None));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+  EXPECT_TRUE(File.hasUniqueID(*TempID));
+}
+
+struct CaptureLastBufferOutputBackend : public StableUniqueEntityAdaptor<> {
+  struct File : public OutputFile {
+    Error storeContentBuffer(ContentBuffer &Content) final {
+      Storage = Content.takeBuffer(getPath());
+      return Error::success();
+    }
+
+    File(StringRef Path, std::unique_ptr<MemoryBuffer> &Storage)
+        : OutputFile(Path), Storage(Storage) {}
+
+    std::unique_ptr<MemoryBuffer> &Storage;
+  };
+
+  Expected<std::unique_ptr<OutputFile>> createFileImpl(StringRef Path,
+                                                       OutputConfig) final {
+    return std::make_unique<File>(Path, Storage);
+  }
+
+  std::unique_ptr<MemoryBuffer> &Storage;
+  CaptureLastBufferOutputBackend(std::unique_ptr<MemoryBuffer> &Storage)
+      : StableUniqueEntityAdaptorType(sys::path::Style::native),
+        Storage(Storage) {}
+};
+
+TEST_F(OutputBackendTest, OnDiskWriteThroughForward) {
+  auto OnDiskBackend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  OnDiskBackend->getSettings().WriteThrough.Use = true;
+  OnDiskBackend->getSettings().WriteThrough.Forward = true;
+
+  std::unique_ptr<MemoryBuffer> Buffer;
+  auto Backend = makeMirroringOutputBackend(
+      std::move(OnDiskBackend),
+      makeIntrusiveRefCnt<CaptureLastBufferOutputBackend>(Buffer));
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write enough data to get a write-through buffer, and add one to ensure
+  // it's not page-aligned.
+  std::string Data;
+  Data.append(OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer + 1,
+              'z');
+  *O->takeOS() << Data;
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(Data));
+
+  // Check that the saved buffer is a write-through buffer.
+  EXPECT_TRUE(Buffer);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ(Data, Buffer->getBuffer());
+  EXPECT_EQ(MemoryBuffer::MemoryBuffer_MMap, Buffer->getBufferKind());
+}
+
+TEST_F(OutputBackendTest, OnDiskWriteThroughForwardTooSmall) {
+  auto OnDiskBackend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  OnDiskBackend->getSettings().WriteThrough.Use = true;
+  OnDiskBackend->getSettings().WriteThrough.Forward = true;
+
+  std::unique_ptr<MemoryBuffer> Buffer;
+  auto Backend = makeMirroringOutputBackend(
+      std::move(OnDiskBackend),
+      makeIntrusiveRefCnt<CaptureLastBufferOutputBackend>(Buffer));
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write almost enough data to return write-through buffer, but not quite.
+  std::string Data;
+  Data.append(OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer - 1,
+              'z');
+  *O->takeOS() << Data;
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(Data));
+
+  // Check that the saved buffer is not write-through buffer.
+  EXPECT_TRUE(Buffer);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ(Data, Buffer->getBuffer());
+  EXPECT_EQ(MemoryBuffer::MemoryBuffer_Malloc, Buffer->getBufferKind());
+}
+
+TEST_F(OutputBackendTest, FilteredOnDisk) {
+  auto Backend =
+      makeFilteringOutputBackend(makeIntrusiveRefCnt<OnDiskOutputBackend>(),
+                                 [](StringRef, OutputConfig) { return true; });
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close. The content should be there.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+}
+
+TEST_F(OutputBackendTest, FilteredOnDiskSkipped) {
+  auto Backend =
+      makeFilteringOutputBackend(makeIntrusiveRefCnt<OnDiskOutputBackend>(),
+                                 [](StringRef, OutputConfig) { return false; });
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close. It should not exist on disk.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(None));
+}
+
+TEST_F(OutputBackendTest, InMemory) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  ASSERT_FALSE(FS->exists(Path));
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  ASSERT_FALSE(FS->exists(Path));
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file.
+  ASSERT_TRUE(FS->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, Path);
+  EXPECT_EQ(Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, InMemoryFailIfExists) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+
+  // Add a conflicting file to FS.
+  StringRef Path = "//root/in/memory.data";
+  FS->addFile(Path, 0, MemoryBuffer::getMemBuffer("some data"));
+
+  // Check that we get the error from failing to clobber the in-memory file.
+  Backend->getSettings().FailIfExists = true;
+  auto Expected = Backend->createFile(Path);
+  ASSERT_FALSE(Expected);
+  std::error_code EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+
+  // No error if we turn off the flag though.
+  Backend->getSettings().FailIfExists = false;
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Writing identical data should be okay.
+  *O->takeOS() << "some data";
+  ASSERT_FALSE(errorToBool(O->close()));
+}
+
+TEST_F(OutputBackendTest, InMemoryMismatchedContent) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+  Backend->getSettings().FailIfExists = false;
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  ASSERT_FALSE(FS->exists(Path));
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_FALSE(FS->exists(Path));
+  ASSERT_TRUE(O);
+
+  // Add a conflicting file to FS.
+  FS->addFile(Path, 0, MemoryBuffer::getMemBuffer("old data"));
+  ASSERT_TRUE(FS->exists(Path));
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "new data";
+  Error E = O->close();
+
+  // Check the error.
+  ASSERT_TRUE(bool(E));
+  std::error_code EC = errorToErrorCode(std::move(E));
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+}
+
+TEST_F(OutputBackendTest, InMemoryNoOverwrite) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+  Backend->getSettings().FailIfExists = false;
+
+  // Create the output once. This should be fine.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(
+      Backend->createFile(Path, {OutputConfigFlag::NoOverwrite}));
+  ASSERT_TRUE(O);
+  *O->takeOS() << "some data";
+  ASSERT_FALSE(errorToBool(O->close()));
+
+  // Doing it again should fail.
+  auto Expected = Backend->createFile(Path, {OutputConfigFlag::NoOverwrite});
+  ASSERT_FALSE(Expected);
+  std::error_code EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+
+  // It should fail even in a different backend.
+  Backend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+  Backend->getSettings().FailIfExists = false;
+  Expected = Backend->createFile(Path, {OutputConfigFlag::NoOverwrite});
+  ASSERT_FALSE(Expected);
+  EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemory) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<OnDiskOutputBackend>(),
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent("some data"));
+
+  // Lookup the file in FS.
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, File.Path);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryFailIfExists) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto InMemoryBackend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS);
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<OnDiskOutputBackend>(), InMemoryBackend);
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Add a file with the same name to FS.
+  FS->addFile(File.Path, 0, MemoryBuffer::getMemBuffer("some data"));
+
+  // Check that we get the error from failing to clobber the in-memory file.
+  InMemoryBackend->getSettings().FailIfExists = true;
+  auto Expected = Backend->createFile(File.Path);
+  ASSERT_FALSE(Expected);
+  std::error_code EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+
+  // No error if we turn off the flag though.
+  InMemoryBackend->getSettings().FailIfExists = false;
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Writing identical data should be okay.
+  *O->takeOS() << "some data";
+  ASSERT_FALSE(errorToBool(O->close()));
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryMismatchedContent) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<OnDiskOutputBackend>(),
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the output.
+  ASSERT_FALSE(FS->exists(File.Path));
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_FALSE(FS->exists(File.Path));
+  ASSERT_TRUE(O);
+
+  // Add a conflicting file to FS.
+  FS->addFile(File.Path, 0, MemoryBuffer::getMemBuffer("old data"));
+  ASSERT_TRUE(FS->exists(File.Path));
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "new data";
+  Error E = O->close();
+
+  // Check the error.
+  ASSERT_TRUE(bool(E));
+  std::error_code EC = errorToErrorCode(std::move(E));
+  EXPECT_EQ(int(std::errc::file_exists), EC.value());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryNoImplyCreateDirectories) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<OnDiskOutputBackend>(),
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "missing", "on-disk.data");
+
+  // Check that we get the error from failing to create the missing directory
+  // on-disk.
+  auto Expected = Backend->createFile(
+      File.Path, {OutputConfigFlag::NoImplyCreateDirectories});
+  ASSERT_FALSE(Expected);
+  std::error_code EC = errorToErrorCode(Expected.takeError());
+  EXPECT_EQ(int(std::errc::no_such_file_or_directory), EC.value());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryWriteThrough) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto OnDiskBackend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  auto Backend = makeMirroringOutputBackend(
+      OnDiskBackend, makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+  OnDiskBackend->getSettings().WriteThrough.Use = true;
+  OnDiskBackend->getSettings().WriteThrough.Forward = true;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write enough data to get a write-through buffer, and add one to ensure
+  // it's not page-aligned.
+  std::string Data;
+  Data.append(OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer + 1,
+              'z');
+  *O->takeOS() << Data;
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(Data));
+
+  // Lookup the file in FS.
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, File.Path);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ(Data, Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryWriteThroughPageAligned) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto OnDiskBackend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  auto Backend = makeMirroringOutputBackend(
+      OnDiskBackend, makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+  OnDiskBackend->getSettings().WriteThrough.Use = true;
+  OnDiskBackend->getSettings().WriteThrough.Forward = true;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write just enough data to get a write-through buffer. It'll likely be
+  // page-aligned.
+  std::string Data;
+  Data.append(OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer, 'z');
+  *O->takeOS() << Data;
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(Data));
+
+  // Lookup the file in FS. Ensure no errors when it creates a null-terminated
+  // reference to the buffer.
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, File.Path);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ(Data, Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, MirrorOnDiskInMemoryWriteThroughTooSmall) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto OnDiskBackend = makeIntrusiveRefCnt<OnDiskOutputBackend>();
+  auto Backend = makeMirroringOutputBackend(
+      OnDiskBackend, makeIntrusiveRefCnt<InMemoryOutputBackend>(FS));
+  OnDiskBackend->getSettings().WriteThrough.Use = true;
+  OnDiskBackend->getSettings().WriteThrough.Forward = true;
+
+  // Get a filename we can use on disk.
+  ASSERT_TRUE(makeTempDirectory());
+  OnDiskFile File(*D, "on-disk.data");
+
+  // Create the file.
+  auto O = expectedToPointer(Backend->createFile(File.Path));
+  ASSERT_TRUE(O);
+
+  // Write almost (but not quite) enough data to get a write-through buffer.
+  std::string Data;
+  Data.append(OnDiskOutputBackend::MinimumSizeToReturnWriteThroughBuffer - 1,
+              'z');
+  *O->takeOS() << Data;
+  EXPECT_FALSE(errorToBool(O->close()));
+  EXPECT_TRUE(File.equalsCurrentContent(Data));
+
+  // Lookup the file in FS.
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, File.Path);
+  EXPECT_EQ(File.Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ(Data, Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, FilteredInMemory) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend =
+      makeFilteringOutputBackend(makeIntrusiveRefCnt<InMemoryOutputBackend>(FS),
+                                 [](StringRef, OutputConfig) { return true; });
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file.
+  ASSERT_TRUE(FS->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer = openBufferForRead(*FS, Path);
+  EXPECT_EQ(Path, Buffer->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer->getBuffer());
+}
+
+TEST_F(OutputBackendTest, FilteredInMemorySkipped) {
+  auto FS = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend =
+      makeFilteringOutputBackend(makeIntrusiveRefCnt<InMemoryOutputBackend>(FS),
+                                 [](StringRef, OutputConfig) { return false; });
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  ASSERT_FALSE(FS->exists(Path));
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // The file should have been filtered out.
+  ASSERT_FALSE(FS->exists(Path));
+}
+
+TEST_F(OutputBackendTest, MirrorFilteredInMemoryInMemoryNotFiltered) {
+  auto FS1 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto FS2 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeFilteringOutputBackend(
+          makeIntrusiveRefCnt<InMemoryOutputBackend>(FS1),
+          [](StringRef, OutputConfig) { return false; }),
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS2));
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file. It should only be skipped in FS1.
+  EXPECT_TRUE(!FS1->exists(Path));
+  ASSERT_TRUE(FS2->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer2 = openBufferForRead(*FS2, Path);
+  ASSERT_TRUE(Buffer2);
+  EXPECT_EQ(Path, Buffer2->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer2->getBuffer());
+}
+
+TEST_F(OutputBackendTest, MirrorInMemoryWithFilteredInMemory) {
+  auto FS1 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto FS2 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS1),
+      makeFilteringOutputBackend(
+          makeIntrusiveRefCnt<InMemoryOutputBackend>(FS2),
+          [](StringRef, OutputConfig) { return false; }));
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file. It should only be skipped in FS1.
+  EXPECT_TRUE(!FS2->exists(Path));
+  ASSERT_TRUE(FS1->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer2 = openBufferForRead(*FS1, Path);
+  ASSERT_TRUE(Buffer2);
+  EXPECT_EQ(Path, Buffer2->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer2->getBuffer());
+}
+
+TEST_F(OutputBackendTest, MirrorInMemoryInMemory) {
+  auto FS1 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto FS2 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS1),
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS2));
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file.
+  ASSERT_TRUE(FS1->exists(Path));
+  ASSERT_TRUE(FS2->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer1 = openBufferForRead(*FS1, Path);
+  std::unique_ptr<MemoryBuffer> Buffer2 = openBufferForRead(*FS2, Path);
+  ASSERT_TRUE(Buffer1);
+  ASSERT_TRUE(Buffer2);
+  EXPECT_EQ(Path, Buffer1->getBufferIdentifier());
+  EXPECT_EQ(Path, Buffer2->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer1->getBuffer());
+  EXPECT_EQ("some data", Buffer2->getBuffer());
+
+  // Should be a reference to the same memory.
+  EXPECT_EQ(Buffer1->getBufferStart(), Buffer2->getBufferStart());
+}
+
+TEST_F(OutputBackendTest, MirrorInMemoryInMemoryOwnBufferForMirror) {
+  auto FS1 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto FS2 = makeIntrusiveRefCnt<InMemoryFileSystem>();
+  auto CopyingBackend = makeIntrusiveRefCnt<InMemoryOutputBackend>(FS2);
+  CopyingBackend->getSettings().CopyUnownedBuffers = true;
+  auto Backend = makeMirroringOutputBackend(
+      makeIntrusiveRefCnt<InMemoryOutputBackend>(FS1),
+      std::move(CopyingBackend));
+
+  // Create the output.
+  StringRef Path = "//root/in/memory.data";
+  auto O = expectedToPointer(Backend->createFile(Path));
+  ASSERT_TRUE(O);
+
+  // Write some data into it, flush, and close.
+  *O->takeOS() << "some data";
+  EXPECT_FALSE(errorToBool(O->close()));
+
+  // Lookup the file.
+  ASSERT_TRUE(FS1->exists(Path));
+  ASSERT_TRUE(FS2->exists(Path));
+  std::unique_ptr<MemoryBuffer> Buffer1 = openBufferForRead(*FS1, Path);
+  std::unique_ptr<MemoryBuffer> Buffer2 = openBufferForRead(*FS2, Path);
+  ASSERT_TRUE(Buffer1);
+  ASSERT_TRUE(Buffer2);
+  EXPECT_EQ(Path, Buffer1->getBufferIdentifier());
+  EXPECT_EQ(Path, Buffer2->getBufferIdentifier());
+  EXPECT_EQ("some data", Buffer1->getBuffer());
+  EXPECT_EQ("some data", Buffer2->getBuffer());
+
+  // Should be a copy.
+  EXPECT_NE(Buffer1->getBufferStart(), Buffer2->getBufferStart());
+}
+
+} // anonymous namespace

llvm/unittests/Support/OutputConfigTest.cpp

+//===- unittests/Support/OutputConfigTest.cpp - OutputConfig tests --------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/OutputBackend.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::vfs;
+
+namespace {
+
+TEST(OutputConfigTest, construct) {
+  EXPECT_TRUE(OutputConfig().none());
+  EXPECT_FALSE(OutputConfig().test(OutputConfigFlag::Text));
+  EXPECT_FALSE(OutputConfig().test(OutputConfigFlag::NoCrashCleanup));
+
+  {
+    OutputConfig Config = {OutputConfigFlag::NoCrashCleanup};
+    EXPECT_FALSE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+
+  {
+    OutputConfig Config = {OutputConfigFlag::Text,
+                           OutputConfigFlag::NoCrashCleanup};
+    EXPECT_FALSE(Config.none());
+    EXPECT_TRUE(Config.test(OutputConfigFlag::Text));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+}
+
+TEST(OutputConfigTest, set) {
+  {
+    // Set one.
+    OutputConfig Config;
+    Config.set(OutputConfigFlag::Text);
+    EXPECT_FALSE(Config.none());
+    EXPECT_TRUE(Config.test(OutputConfigFlag::Text));
+    EXPECT_FALSE(Config.test(OutputConfigFlag::NoCrashCleanup));
+
+    // Undo it.
+    Config.set(OutputConfigFlag::Text, false);
+    EXPECT_TRUE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_FALSE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+
+  {
+    // Set multiple.
+    OutputConfig Config;
+    Config.set({OutputConfigFlag::Text, OutputConfigFlag::NoCrashCleanup,
+                OutputConfigFlag::NoImplyCreateDirectories});
+    EXPECT_FALSE(Config.none());
+    EXPECT_TRUE(Config.test(OutputConfigFlag::Text));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoImplyCreateDirectories));
+
+    // Undo two of them.
+    Config.set(
+        {OutputConfigFlag::Text, OutputConfigFlag::NoImplyCreateDirectories},
+        false);
+    EXPECT_FALSE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_FALSE(Config.test(OutputConfigFlag::NoImplyCreateDirectories));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+}
+
+TEST(OutputConfigTest, reset) {
+  {
+    // Reset one.
+    OutputConfig Config = {OutputConfigFlag::Text,
+                           OutputConfigFlag::NoCrashCleanup};
+    Config.reset(OutputConfigFlag::Text);
+    EXPECT_FALSE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+
+  {
+    // Reset both.
+    OutputConfig Config = {OutputConfigFlag::Text,
+                           OutputConfigFlag::NoCrashCleanup};
+    Config.reset({OutputConfigFlag::Text, OutputConfigFlag::NoCrashCleanup});
+    EXPECT_TRUE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_FALSE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+
+  {
+    // Reset multiple (but not all).
+    OutputConfig Config = {OutputConfigFlag::Text,
+                           OutputConfigFlag::NoCrashCleanup,
+                           OutputConfigFlag::NoImplyCreateDirectories};
+    Config.reset(
+        {OutputConfigFlag::Text, OutputConfigFlag::NoImplyCreateDirectories});
+    EXPECT_FALSE(Config.none());
+    EXPECT_FALSE(Config.test(OutputConfigFlag::Text));
+    EXPECT_FALSE(Config.test(OutputConfigFlag::NoImplyCreateDirectories));
+    EXPECT_TRUE(Config.test(OutputConfigFlag::NoCrashCleanup));
+  }
+}
+
+} // anonymous namespace