[lld-macho] Enable copy-on-write for input buffers

[int3]

Summary

The Mach-O format makes extensive use of embedded addends,
particularly for x86_64. This makes ICF's job a bit more difficult:
sections that are otherwise semantically identical may have different
raw bytes due to the embedded addends. Hashing and comparing the raw
bytes naively means that we miss folding opportunities.

This diff canonicalizes these sections by writing over those embedded
addends with zeros. In order to make this possible, the our previously
read-only MemoryBuffers need to be made into copy-on-write.

This requires some awkward casts, but I'm not sure there's a better way to do
things...

[thakis]

How much of a difference does ICF'ing these make?

[int3]

Right now, pretty small. (0.3% for the internal build I'm testing, and 0.002% for chromium_framework.) But I'm building upon this to apply ICF to functions that have unwind info, since CompactUnwindEntries use unsigned section relocations -- which embed their addends -- to refer to functions. This has a much larger impact -- 3.2% for the internal build, about doubling the impact that ICF currently has. Not sure about chromium_framework yet, as my implementation is currently crashing.

OTOH, we might want CompactUnwindEntries to eventually use a special-cased subclass of InputSection for performance reasons, and that subclass could just ignore the functionAddress pointer when doing hashing / equality comparison. So deduping code with embedded addends is not a strict prerequisite. However, it does make the initial implementation of unwind ICF simpler, and moreover the code complexity here is largely self-contained -- unlike adding a new subclass, we don't have to add extra handling code throughout the linker.

[thevinster]

Looks pretty good to me, other than the comment about the casting.

llvm/lib/Support/MemoryBufferRef.cpp

21

Is there any way to prevent casting if this was called on a non-writeable buffer? I was thinking of some flag based approach that is set for writeable buffer and have that be determine whether casting can be done. That way, this can be a bit safer than having to let the developer have context about whether this is safe or not.

[dblaikie]

Any idea what ld64 does in this case? Might be worth checking (should be testable, I think - give it a really big input section that it needs to canonicalize/fold, and see if that produces more total memory usage than if the section is small?) - and if it doesn't have the same negative effect on memory usage, maybe that's a hint that there's some other lower-(memory)-cost solution to the problem?

[dexonsmith]

In D106213#2905606, @dblaikie wrote:

Any idea what ld64 does in this case? Might be worth checking (should be testable, I think - give it a really big input section that it needs to canonicalize/fold, and see if that produces more total memory usage than if the section is small?) - and if it doesn't have the same negative effect on memory usage, maybe that's a hint that there's some other lower-(memory)-cost solution to the problem?

I believe ld64 takes a different approach: it treats the fixups as-if-zero when comparing/hashing content, without sacrificing the mmap optimization.

[int3]

I am not able to get ld64 to dedup even the simplest of functions, let alone more complicated cases like these. Or perhaps I'm missing something in how ld64 is supposed to be invoked... this is what I've tried:

(base) ~/tmp: cat test.s
.text
.weak_definition _foo
.weak_definition _bar
.weak_definition _baz

_foo:
  ret

_bar:
  ret

_baz:
  ret

.subsections_via_symbols

(base) ~/tmp: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 test.s > test.o
(base) ~/tmp: ld test.o -o test -dylib
(base) ~/tmp: llvm-objdump -d test

test:	file format mach-o 64-bit x86-64

Disassembly of section __TEXT,__text:

0000000000003fb5 <_foo>:
    3fb5: c3                           	retq

0000000000003fb6 <_bar>:
    3fb6: c3                           	retq

0000000000003fb7 <_baz>:
    3fb7: c3                           	retq

[thakis]

In D106213#2889390, @int3 wrote:

Right now, pretty small. (0.3% for the internal build I'm testing, and 0.002% for chromium_framework.) But I'm building upon this to apply ICF to functions that have unwind info, since CompactUnwindEntries use unsigned section relocations -- which embed their addends -- to refer to functions. This has a much larger impact -- 3.2% for the internal build, about doubling the impact that ICF currently has. Not sure about chromium_framework yet, as my implementation is currently crashing.

How much size win do you need to catch up to ld64?

(It's probably clear that I'm asking because this seems like a somewhat ugly change conceptually, and I'm wondering if it's worth it.)

[dexonsmith]

In D106213#2905976, @int3 wrote:

I am not able to get ld64 to dedup even the simplest of functions, let alone more complicated cases like these.

It's not safe to dedup symbols in general, since it's not always known if their addresses are compared.

Mach-O can be marked "autohide" or .weak_def_can_be_hidden, something LLVM sets on symbols when GlobalValue::canBeOmittedFromSymbolTable (see https://github.com/llvm/llvm-project/blob/main/llvm/lib/IR/Globals.cpp#L311 or grep for MCSA_WeakDefAutoPrivate) -- that is, when a symbol is linkonce_odr and unnamed_addr. GlobalVariables that are also const can just be local_unnamed_addr. For C++ code, this should be true for most inlines and templates.

ld64 reuses this autohide flag to trigger dedup only when it's safe.

lld/MachO/Arch/ARM.cpp

 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
 struct ARM : TargetInfo {
   ARM(uint32_t cpuSubtype);
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
+  int64_t getEmbeddedAddend(WritableMemoryBufferRef, uint64_t offset,
                             const relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t pc) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;

 #undef B
   }};
   assert(type < relocAttrsArray.size() && "invalid relocation type");
   if (type >= relocAttrsArray.size())
     return invalidRelocAttrs;
   return relocAttrsArray[type];
 }
 
-int64_t ARM::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+int64_t ARM::getEmbeddedAddend(WritableMemoryBufferRef mb, uint64_t offset,
                                relocation_info rel) const {
   // FIXME: implement this
   return 0;
 }
 
 template <int N> using BitfieldFlag = Bitfield::Element<bool, N, 1>;
 
 // ARM BL encoding:

lld/MachO/Arch/ARM64Common.h

 #include "llvm/BinaryFormat/MachO.h"
 
 namespace lld {
 namespace macho {
 
 struct ARM64Common : TargetInfo {
   template <class LP> ARM64Common(LP lp) : TargetInfo(lp) {}
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
+  int64_t getEmbeddedAddend(llvm::WritableMemoryBufferRef, uint64_t offset,
                             const llvm::MachO::relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t pc) const override;
 
   void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
   uint64_t getPageSize() const override { return 16 * 1024; }
 };
 

lld/MachO/Arch/ARM64Common.cpp

 //===- ARM64Common.cpp ----------------------------------------------------===//
 //
 // 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 "Arch/ARM64Common.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Support/Endian.h"
 
+using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
-int64_t ARM64Common::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+int64_t ARM64Common::getEmbeddedAddend(WritableMemoryBufferRef mb,
+                                       uint64_t offset,
                                        const relocation_info rel) const {
   if (rel.r_type != ARM64_RELOC_UNSIGNED &&
       rel.r_type != ARM64_RELOC_SUBTRACTOR) {
     // All other reloc types should use the ADDEND relocation to store their
     // addends.
     // TODO(gkm): extract embedded addend just so we can assert that it is 0
     return 0;
   }

lld/MachO/Arch/X86_64.cpp

 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Endian.h"
 
+using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
 struct X86_64 : TargetInfo {
   X86_64();
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
+  int64_t getEmbeddedAddend(WritableMemoryBufferRef, uint64_t offset,
                             const relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t relocVA) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
case X86_64_RELOC_SIGNED_2:
     return 2;
   case X86_64_RELOC_SIGNED_4:
     return 4;
   default:
     return 0;
   }
 }
 
-int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+int64_t X86_64::getEmbeddedAddend(WritableMemoryBufferRef mb, uint64_t offset,
                                   relocation_info rel) const {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   const uint8_t *loc = buf + offset + rel.r_address;
 
   switch (rel.r_length) {
   case 2:
     return static_cast<int32_t>(read32le(loc)) + pcrelOffset(rel.r_type);
   case 3:

lld/MachO/Driver.h

 
 void parseLCLinkerOption(InputFile *, unsigned argc, StringRef data);
 
 std::string createResponseFile(const llvm::opt::InputArgList &args);
 
 // Check for both libfoo.dylib and libfoo.tbd (in that order).
 llvm::Optional<std::string> resolveDylibPath(llvm::StringRef path);
 
-DylibFile *loadDylib(llvm::MemoryBufferRef mbref, DylibFile *umbrella = nullptr,
+DylibFile *loadDylib(llvm::WritableMemoryBufferRef mbref,
+                     DylibFile *umbrella = nullptr,
                      bool isBundleLoader = false);
 
 // Search for all possible combinations of `{root}/{name}.{extension}`.
 // If \p extensions are not specified, then just search for `{root}/{name}`.
 llvm::Optional<llvm::StringRef>
 findPathCombination(const llvm::Twine &name,
                     const std::vector<llvm::StringRef> &roots,
                     ArrayRef<llvm::StringRef> extensions = {""});
 
 // If -syslibroot is specified, absolute paths to non-object files may be
 // rerooted.
 llvm::StringRef rerootPath(llvm::StringRef path);
 
-llvm::Optional<InputFile *> loadArchiveMember(MemoryBufferRef, uint32_t modTime,
+llvm::Optional<InputFile *> loadArchiveMember(llvm::WritableMemoryBufferRef,
+                                              uint32_t modTime,
                                               StringRef archiveName,
                                               bool objCOnly);
 
 uint32_t getModTime(llvm::StringRef path);
 
 void printArchiveMemberLoad(StringRef reason, const InputFile *);
 
 // Map simulator platforms to their underlying device platform.

lld/MachO/Driver.cpp

case OPT_max_relative_cache_size_lto:
       break;
     }
   }
   return CHECK(parseCachePruningPolicy(ltoPolicy), "invalid LTO cache policy");
 }
 
 namespace {
 struct ArchiveMember {
-  MemoryBufferRef mbref;
+  WritableMemoryBufferRef mbref;
   uint32_t modTime;
 };
 } // namespace
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
-static std::vector<ArchiveMember> getArchiveMembers(MemoryBufferRef mb) {
+static std::vector<ArchiveMember>
+getArchiveMembers(WritableMemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
       CHECK(Archive::create(mb),
             mb.getBufferIdentifier() + ": failed to parse archive");
   Archive *archive = file.get();
   make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
 
   std::vector<ArchiveMember> v;
   Error err = Error::success();
 
   // Thin archives refer to .o files, so --reproduce needs the .o files too.
   bool addToTar = archive->isThin() && tar;
 
   for (const Archive::Child &c : archive->children(err)) {
-    MemoryBufferRef mbref =
+    WritableMemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               mb.getBufferIdentifier() +
-                  ": could not get the buffer for a child of the archive");
+                  ": could not get the buffer for a child of the archive")
+            .castToWritable();
     if (addToTar)
       tar->append(relativeToRoot(check(c.getFullName())), mbref.getBuffer());
     uint32_t modTime = toTimeT(
         CHECK(c.getLastModified(), mb.getBufferIdentifier() +
                                        ": could not get the modification "
                                        "time for a child of the archive"));
     v.push_back({mbref, modTime});
   }
   if (err)
     fatal(mb.getBufferIdentifier() +
           ": Archive::children failed: " + toString(std::move(err)));
 
   return v;
 }
 
 static DenseMap<StringRef, ArchiveFile *> loadedArchives;
 
 static InputFile *addFile(StringRef path, bool forceLoadArchive,
                           bool isExplicit = true, bool isBundleLoader = false) {
-  Optional<MemoryBufferRef> buffer = readFile(path);
+  Optional<WritableMemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return nullptr;
-  MemoryBufferRef mbref = *buffer;
+  WritableMemoryBufferRef mbref = *buffer;
   InputFile *newFile = nullptr;
 
   file_magic magic = identify_magic(mbref.getBuffer());
   switch (magic) {
   case file_magic::archive: {
     // Avoid loading archives twice. If the archives are being force-loaded,
     // loading them twice would create duplicate symbol errors. In the
     // non-force-loading case, this is just a minor performance optimization.
     // We don't take a reference to cachedFile here because the
     // loadArchiveMember() call below may recursively call addFile() and
     // invalidate this reference.
     if (ArchiveFile *cachedFile = loadedArchives[path])
       return cachedFile;
 
     std::unique_ptr<object::Archive> file = CHECK(
         object::Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable())
       error(path + ": archive has no index; run ranlib to add one");
 
     if (config->allLoad || forceLoadArchive) {
-      if (Optional<MemoryBufferRef> buffer = readFile(path)) {
+      if (Optional<WritableMemoryBufferRef> buffer = readFile(path)) {
         for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
           if (Optional<InputFile *> file = loadArchiveMember(
                   member.mbref, member.modTime, path, /*objCOnly=*/false)) {
             inputFiles.insert(*file);
             printArchiveMemberLoad(
                 (forceLoadArchive ? "-force_load" : "-all_load"),
                 inputFiles.back());
           }
         }
       }
     } else if (config->forceLoadObjC) {
       for (const object::Archive::Symbol &sym : file->symbols())
         if (sym.getName().startswith(objc::klass))
           symtab->addUndefined(sym.getName(), /*file=*/nullptr,
                                /*isWeakRef=*/false);
 
       // TODO: no need to look for ObjC sections for a given archive member if
       // we already found that it contains an ObjC symbol. We should also
       // consider creating a LazyObjFile class in order to avoid double-loading
       // these files here and below (as part of the ArchiveFile).
-      if (Optional<MemoryBufferRef> buffer = readFile(path)) {
+      if (Optional<WritableMemoryBufferRef> buffer = readFile(path)) {
         for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
           if (Optional<InputFile *> file = loadArchiveMember(
                   member.mbref, member.modTime, path, /*objCOnly=*/true)) {
             inputFiles.insert(*file);
             printArchiveMemberLoad("-ObjC", inputFiles.back());
           }
         }
       }
case OPT_framework:
       break;
     default:
       error(arg->getSpelling() + " is not allowed in LC_LINKER_OPTION");
     }
   }
 }
 
 static void addFileList(StringRef path) {
-  Optional<MemoryBufferRef> buffer = readFile(path);
+  Optional<WritableMemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
-  MemoryBufferRef mbref = *buffer;
+  WritableMemoryBufferRef mbref = *buffer;
   for (StringRef path : args::getLines(mbref))
     addFile(rerootPath(path), /*forceLoadArchive=*/false);
 }
 
 // An order file has one entry per line, in the following format:
 //
 //   <cpu>:<object file>:<symbol name>
 //
 // <cpu> and <object file> are optional. If not specified, then that entry
 // matches any symbol of that name. Parsing this format is not quite
 // straightforward because the symbol name itself can contain colons, so when
 // encountering a colon, we consider the preceding characters to decide if it
 // can be a valid CPU type or file path.
 //
 // If a symbol is matched by multiple entries, then it takes the lowest-ordered
 // entry (the one nearest to the front of the list.)
 //
 // The file can also have line comments that start with '#'.
 static void parseOrderFile(StringRef path) {
-  Optional<MemoryBufferRef> buffer = readFile(path);
+  Optional<WritableMemoryBufferRef> buffer = readFile(path);
   if (!buffer) {
     error("Could not read order file at " + path);
     return;
   }
 
-  MemoryBufferRef mbref = *buffer;
+  WritableMemoryBufferRef mbref = *buffer;
   size_t priority = std::numeric_limits<size_t>::max();
   for (StringRef line : args::getLines(mbref)) {
     StringRef objectFile, symbol;
     line = line.take_until([](char c) { return c == '#'; }); // ignore comments
     line = line.ltrim();
 
     CPUType cpuType = StringSwitch<CPUType>(line)
                           .StartsWith("i386:", CPU_TYPE_I386)

 static void handleSymbolPatterns(InputArgList &args,
                                  SymbolPatterns &symbolPatterns,
                                  unsigned singleOptionCode,
                                  unsigned listFileOptionCode) {
   for (const Arg *arg : args.filtered(singleOptionCode))
     symbolPatterns.insert(arg->getValue());
   for (const Arg *arg : args.filtered(listFileOptionCode)) {
     StringRef path = arg->getValue();
-    Optional<MemoryBufferRef> buffer = readFile(path);
+    Optional<WritableMemoryBufferRef> buffer = readFile(path);
     if (!buffer) {
       error("Could not read symbol file: " + path);
       continue;
     }
-    MemoryBufferRef mbref = *buffer;
+    WritableMemoryBufferRef mbref = *buffer;
     for (StringRef line : args::getLines(mbref)) {
       line = line.take_until([](char c) { return c == '#'; }).trim();
       if (!line.empty())
         symbolPatterns.insert(line);
     }
   }
 }
 
if (!config->exportedSymbols.empty()) {
           if (config->unexportedSymbols.match(defined->getName()))
             defined->privateExtern = true;
     }
 
     for (const Arg *arg : args.filtered(OPT_sectcreate)) {
       StringRef segName = arg->getValue(0);
       StringRef sectName = arg->getValue(1);
       StringRef fileName = arg->getValue(2);
-      Optional<MemoryBufferRef> buffer = readFile(fileName);
+      Optional<WritableMemoryBufferRef> buffer = readFile(fileName);
       if (buffer)
         inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
     }
 
     gatherInputSections();
 
     if (config->deadStrip)
       markLive();

lld/MachO/DriverUtils.cpp

case OPT_reproduce:
       break;
     case OPT_INPUT:
       os << quote(rewriteInputPath(arg->getValue())) << "\n";
       break;
     case OPT_o:
       os << "-o " << quote(path::filename(arg->getValue())) << "\n";
       break;
     case OPT_filelist:
-      if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
+      if (Optional<WritableMemoryBufferRef> buffer = readFile(arg->getValue()))
         for (StringRef path : args::getLines(*buffer))
           os << quote(rewriteInputPath(path)) << "\n";
       break;
     case OPT_force_load:
     case OPT_weak_library:
       os << arg->getSpelling() << " "
          << quote(rewriteInputPath(arg->getValue())) << "\n";
       break;
if (tbdExists)
     return std::string(tbdPath);
   return {};
 }
 
 // It's not uncommon to have multiple attempts to load a single dylib,
 // especially if it's a commonly re-exported core library.
 static DenseMap<CachedHashStringRef, DylibFile *> loadedDylibs;
 
-DylibFile *macho::loadDylib(MemoryBufferRef mbref, DylibFile *umbrella,
+DylibFile *macho::loadDylib(WritableMemoryBufferRef mbref, DylibFile *umbrella,
                             bool isBundleLoader) {
   CachedHashStringRef path(mbref.getBufferIdentifier());
   DylibFile *&file = loadedDylibs[path];
   if (file)
     return file;
 
   DylibFile *newFile;
   file_magic magic = identify_magic(mbref.getBuffer());
StringRef macho::rerootPath(StringRef path) {
 
   if (Optional<StringRef> rerootedPath =
           findPathCombination(path, config->systemLibraryRoots))
     return *rerootedPath;
 
   return path;
 }
 
-Optional<InputFile *> macho::loadArchiveMember(MemoryBufferRef mb,
+Optional<InputFile *> macho::loadArchiveMember(WritableMemoryBufferRef mb,
                                                uint32_t modTime,
                                                StringRef archiveName,
                                                bool objCOnly) {
   if (config->zeroModTime)
     modTime = 0;
 
   switch (identify_magic(mb.getBuffer())) {
   case file_magic::macho_object:

lld/MachO/InputFiles.h

enum Kind {
     ArchiveKind,
     BitcodeKind,
   };
 
   virtual ~InputFile() = default;
   Kind kind() const { return fileKind; }
   StringRef getName() const { return name; }
 
-  MemoryBufferRef mb;
+  llvm::WritableMemoryBufferRef mb;
 
   std::vector<Symbol *> symbols;
   std::vector<SubsectionMap> subsections;
   // Provides an easy way to sort InputFiles deterministically.
   const int id;
 
   // If not empty, this stores the name of the archive containing this file.
   // We use this string for creating error messages.
   std::string archiveName;
 
 protected:
-  InputFile(Kind kind, MemoryBufferRef mb)
+  InputFile(Kind kind, llvm::WritableMemoryBufferRef mb)
       : mb(mb), id(idCount++), fileKind(kind), name(mb.getBufferIdentifier()) {}
 
   InputFile(Kind, const llvm::MachO::InterfaceFile &);
 
 private:
   const Kind fileKind;
   const StringRef name;
 
   static int idCount;
 };
 
 // .o file
 class ObjFile final : public InputFile {
 public:
-  ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName);
+  ObjFile(llvm::WritableMemoryBufferRef mb, uint32_t modTime,
+          StringRef archiveName);
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
   const uint32_t modTime;
   std::vector<ConcatInputSection *> debugSections;
   ArrayRef<llvm::MachO::data_in_code_entry> dataInCodeEntries;
 
 private:
void parseRelocations(ArrayRef<Section> sectionHeaders, const Section &,
                         SubsectionMap &);
   void parseDebugInfo();
   void parseDataInCode();
 };
 
 // command-line -sectcreate file
 class OpaqueFile final : public InputFile {
 public:
-  OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
+  OpaqueFile(llvm::WritableMemoryBufferRef mb, StringRef segName,
+             StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
 // .dylib or .tbd file
 class DylibFile final : public InputFile {
 public:
   // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
   // symbols in those sub-libraries will be available under the umbrella
   // library's namespace. Those sub-libraries can also have their own
   // re-exports. When loading a re-exported dylib, `umbrella` should be set to
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded
   // (through an -lfoo flag), then `umbrella` should be a nullptr.
-  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
+  explicit DylibFile(llvm::WritableMemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader = false);
   explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
                      DylibFile *umbrella = nullptr,
                      bool isBundleLoader = false);
 
-  void parseLoadCommands(MemoryBufferRef mb);
+  void parseLoadCommands(llvm::WritableMemoryBufferRef mb);
   void parseReexports(const llvm::MachO::InterfaceFile &interface);
 
   static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
 
   StringRef installName;
   DylibFile *exportingFile = nullptr;
   DylibFile *umbrella;
   SmallVector<StringRef, 2> rpaths;
private:
   std::unique_ptr<llvm::object::Archive> file;
   // Keep track of children fetched from the archive by tracking
   // which address offsets have been fetched already.
   llvm::DenseSet<uint64_t> seen;
 };
 
 class BitcodeFile final : public InputFile {
 public:
-  explicit BitcodeFile(MemoryBufferRef mb);
+  explicit BitcodeFile(llvm::WritableMemoryBufferRef mb);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
 
   std::unique_ptr<llvm::lto::InputFile> obj;
 };
 
 extern llvm::SetVector<InputFile *> inputFiles;
 
-llvm::Optional<MemoryBufferRef> readFile(StringRef path);
+llvm::Optional<llvm::WritableMemoryBufferRef> readFile(StringRef path);
 
 namespace detail {
 
 template <class CommandType, class... Types>
 std::vector<const CommandType *>
 findCommands(const void *anyHdr, size_t maxCommands, Types... types) {
   std::vector<const CommandType *> cmds;
   std::initializer_list<uint32_t> typesList{types...};

lld/MachO/InputFiles.cpp

if (it->minimum > config->platformInfo.minimum)
     warn(toString(input) + " has version " + it->minimum.getAsString() +
          ", which is newer than target minimum of " +
          config->platformInfo.minimum.getAsString());
 
   return true;
 }
 
 // Open a given file path and return it as a memory-mapped file.
-Optional<MemoryBufferRef> macho::readFile(StringRef path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
+Optional<WritableMemoryBufferRef> macho::readFile(StringRef path) {
+  ErrorOr<std::unique_ptr<WritableMemoryBuffer>> mbOrErr =
+      WritableMemoryBuffer::getFile(path);
   if (std::error_code ec = mbOrErr.getError()) {
     error("cannot open " + path + ": " + ec.message());
     return None;
   }
 
-  std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
-  MemoryBufferRef mbref = mb->getMemBufferRef();
+  std::unique_ptr<WritableMemoryBuffer> &mb = *mbOrErr;
+  WritableMemoryBufferRef mbref = mb->getMemBufferRef().castToWritable();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
 
   // If this is a regular non-fat file, return it.
-  const char *buf = mbref.getBufferStart();
+  char *buf = mbref.getBufferStart();
   const auto *hdr = reinterpret_cast<const fat_header *>(buf);
   if (mbref.getBufferSize() < sizeof(uint32_t) ||
       read32be(&hdr->magic) != FAT_MAGIC) {
     if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
     return mbref;
   }
 
   // Object files and archive files may be fat files, which contain multiple
   // real files for different CPU ISAs. Here, we search for a file that matches
-  // with the current link target and returns it as a MemoryBufferRef.
+  // with the current link target and returns it as a WritableMemoryBufferRef.
   const auto *arch = reinterpret_cast<const fat_arch *>(buf + sizeof(*hdr));
 
   for (uint32_t i = 0, n = read32be(&hdr->nfat_arch); i < n; ++i) {
     if (reinterpret_cast<const char *>(arch + i + 1) >
         buf + mbref.getBufferSize()) {
       error(path + ": fat_arch struct extends beyond end of file");
       return None;
     }
 
     if (read32be(&arch[i].cputype) != static_cast<uint32_t>(target->cpuType) ||
         read32be(&arch[i].cpusubtype) != target->cpuSubtype)
       continue;
 
     uint32_t offset = read32be(&arch[i].offset);
     uint32_t size = read32be(&arch[i].size);
     if (offset + size > mbref.getBufferSize())
       error(path + ": slice extends beyond end of file");
     if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
-    return MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
+    return WritableMemoryBufferRef(MutableArrayRef<char>(buf + offset, size),
+                                   path.copy(bAlloc));
   }
 
   error("unable to find matching architecture in " + path);
   return None;
 }
 
 InputFile::InputFile(Kind kind, const InterfaceFile &interface)
     : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
error(message("has width " + std::to_string(1 << rel.r_length) +
                   " bytes"));
   }
   return valid;
 }
 
 template <class Section>
 void ObjFile::parseRelocations(ArrayRef<Section> sectionHeaders,
                                const Section &sec, SubsectionMap &subsecMap) {
-  auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
+  auto *buf = reinterpret_cast<uint8_t *>(mb.getBufferStart());
   ArrayRef<relocation_info> relInfos(
       reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
 
   auto subsecIt = subsecMap.rbegin();
   for (size_t i = 0; i < relInfos.size(); i++) {
     // Paired relocations serve as Mach-O's method for attaching a
     // supplemental datum to a primary relocation record. ELF does not
     // need them because the *_RELOC_RELA records contain the extra
for (size_t i = 0; i < relInfos.size(); i++) {
     }
     assert(i < relInfos.size());
     if (!validateRelocationInfo(this, sec, relInfo))
       continue;
 
     bool isSubtrahend =
         target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND);
     int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
+    // If we will be running ICF, zero out the embedded addend. This makes it
+    // easier for ICF to compare just the non-relocatable section data.
+    if (config->icfLevel != ICFLevel::none && embeddedAddend != 0)
+      writeAddress(reinterpret_cast<uint8_t *>(mb.getBufferStart()) +
+                       sec.offset + relInfo.r_address,
+                   0, relInfo.r_length);
     assert(!(embeddedAddend && pairedAddend));
     int64_t totalAddend = pairedAddend + embeddedAddend;
     Reloc r;
     r.type = relInfo.r_type;
     r.pcrel = relInfo.r_pcrel;
     r.length = relInfo.r_length;
     r.offset = relInfo.r_address;
     if (relInfo.r_extern) {
for (size_t j = 0; j < symbolIndices.size(); ++j) {
       // emulating that behavior.
       nextIsec->align = MinAlign(sectionAlign, sym.n_value);
       subsecMap.push_back({sym.n_value - sectionAddr, nextIsec});
       subsecEntry = subsecMap.back();
     }
   }
 }
 
-OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
+OpaqueFile::OpaqueFile(WritableMemoryBufferRef mb, StringRef segName,
                        StringRef sectName)
     : InputFile(OpaqueKind, mb) {
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<uint8_t> data = {buf, mb.getBufferSize()};
   ConcatInputSection *isec =
       make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16),
                                /*file=*/this, data);
   isec->live = true;
   subsections.push_back({{0, isec}});
 }
 
-ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
+ObjFile::ObjFile(WritableMemoryBufferRef mb, uint32_t modTime,
+                 StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {
   this->archiveName = std::string(archiveName);
   if (target->wordSize == 8)
     parse<LP64>();
   else
     parse<ILP32>();
 }
 
void ObjFile::parseDataInCode() {
   assert(is_sorted(dataInCodeEntries, [](const data_in_code_entry &lhs,
                                          const data_in_code_entry &rhs) {
     return lhs.offset < rhs.offset;
   }));
 }
 
 // The path can point to either a dylib or a .tbd file.
 static DylibFile *loadDylib(StringRef path, DylibFile *umbrella) {
-  Optional<MemoryBufferRef> mbref = readFile(path);
+  Optional<WritableMemoryBufferRef> mbref = readFile(path);
   if (!mbref) {
     error("could not read dylib file at " + path);
     return nullptr;
   }
   return loadDylib(*mbref, umbrella);
 }
 
 // TBD files are parsed into a series of TAPI documents (InterfaceFiles), with

 
 static void loadReexport(StringRef path, DylibFile *umbrella,
                          const InterfaceFile *currentTopLevelTapi) {
   DylibFile *reexport = findDylib(path, umbrella, currentTopLevelTapi);
   if (!reexport)
     error("unable to locate re-export with install name " + path);
 }
 
-DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
+DylibFile::DylibFile(WritableMemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader)
     : InputFile(DylibKind, mb), refState(RefState::Unreferenced),
       isBundleLoader(isBundleLoader) {
   assert(!isBundleLoader || !umbrella);
   if (umbrella == nullptr)
     umbrella = this;
   this->umbrella = umbrella;
 
parseTrie(buf + c->export_off, c->export_size,
                                                    isWeakDef, isTlv));
               });
   } else {
     error("LC_DYLD_INFO_ONLY not found in " + toString(this));
     return;
   }
 }
 
-void DylibFile::parseLoadCommands(MemoryBufferRef mb) {
+void DylibFile::parseLoadCommands(WritableMemoryBufferRef mb) {
   auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
   const uint8_t *p = reinterpret_cast<const uint8_t *>(mb.getBufferStart()) +
                      target->headerSize;
   for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const load_command *>(p);
     p += cmd->cmdsize;
 
     if (!(hdr->flags & MH_NO_REEXPORTED_DYLIBS) &&

 }
 
 void DylibFile::checkAppExtensionSafety(bool dylibIsAppExtensionSafe) const {
   if (config->applicationExtension && !dylibIsAppExtensionSafe)
     warn("using '-application_extension' with unsafe dylib: " + toString(this));
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<object::Archive> &&f)
-    : InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {
+    : InputFile(ArchiveKind, f->getMemoryBufferRef().castToWritable()),
+      file(std::move(f)) {
   for (const object::Archive::Symbol &sym : file->symbols())
     symtab->addLazy(sym.getName(), this, sym);
 }
 
 void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
   object::Archive::Child c =
       CHECK(sym.getMember(), toString(this) +
                                  ": could not get the member for symbol " +
                                  toMachOString(sym));
 
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
-  MemoryBufferRef mb =
+  WritableMemoryBufferRef mb =
       CHECK(c.getMemoryBufferRef(),
             toString(this) +
                 ": could not get the buffer for the member defining symbol " +
-                toMachOString(sym));
+                toMachOString(sym))
+          .castToWritable();
 
   if (tar && c.getParent()->isThin())
     tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb.getBuffer());
 
   uint32_t modTime = toTimeT(
       CHECK(c.getLastModified(), toString(this) +
                                      ": could not get the modification time "
                                      "for the member defining symbol " +
static macho::Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &objSym,
 
   return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
                             /*size=*/0, objSym.isWeak(), isPrivateExtern,
                             /*isThumb=*/false,
                             /*isReferencedDynamically=*/false,
                             /*noDeadStrip=*/false);
 }
 
-BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
+BitcodeFile::BitcodeFile(WritableMemoryBufferRef mbref)
     : InputFile(BitcodeKind, mbref) {
   obj = check(lto::InputFile::create(mbref));
 
   // Convert LTO Symbols to LLD Symbols in order to perform resolution. The
   // "winning" symbol will then be marked as Prevailing at LTO compilation
   // time.
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(objSym, *this));
 }
 
 template void ObjFile::parse<LP64>();

lld/MachO/LTO.h

public:
   BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<ObjFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<llvm::SmallString<0>> buf;
-  std::vector<std::unique_ptr<llvm::MemoryBuffer>> files;
+  std::vector<std::unique_ptr<llvm::WritableMemoryBuffer>> files;
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/LTO.cpp

std::vector<ObjFile *> BitcodeCompiler::compile() {
   buf.resize(maxTasks);
   files.resize(maxTasks);
 
   // The -cache_path_lto option specifies the path to a directory in which
   // to cache native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache cache;
   if (!config->thinLTOCacheDir.empty())
-    cache = check(
-        lto::localCache(config->thinLTOCacheDir,
-                        [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
-                          files[task] = std::move(mb);
-                        }));
+    cache = check(lto::localCache(
+        config->thinLTOCacheDir,
+        [&](size_t task, std::unique_ptr<WritableMemoryBuffer> mb) {
 
   checkError(ltoObj->run(
       [&](size_t task) {
         return std::make_unique<lto::NativeObjectStream>(
             std::make_unique<raw_svector_ostream>(buf[task]));
       },
       cache));
 
if (!config->ltoObjPath.empty()) {
       filePath = config->ltoObjPath;
       path::append(filePath, Twine(i) + "." +
                                  getArchitectureName(config->arch()) +
                                  ".lto.o");
       saveBuffer(buf[i], filePath);
       modTime = getModTime(filePath);
     }
     ret.push_back(make<ObjFile>(
-        MemoryBufferRef(buf[i], saver.save(filePath.str())), modTime, ""));
+        WritableMemoryBufferRef(buf[i], saver.save(filePath.str())), modTime,
+        ""));
   }
-  for (std::unique_ptr<MemoryBuffer> &file : files)
+  for (std::unique_ptr<WritableMemoryBuffer> &file : files)
     if (file)
       ret.push_back(make<ObjFile>(*file, 0, ""));
   return ret;
 }

lld/MachO/ObjC.h

 
 constexpr const char klass[] = "_OBJC_CLASS_$_";
 constexpr const char metaclass[] = "_OBJC_METACLASS_$_";
 constexpr const char ehtype[] = "_OBJC_EHTYPE_$_";
 constexpr const char ivar[] = "_OBJC_IVAR_$_";
 
 } // namespace objc
 
-bool hasObjCSection(llvm::MemoryBufferRef);
+bool hasObjCSection(llvm::WritableMemoryBufferRef);
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/ObjC.cpp

 
 #include "llvm/BinaryFormat/MachO.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
-template <class LP> static bool hasObjCSection(MemoryBufferRef mb) {
+template <class LP> static bool hasObjCSection(WritableMemoryBufferRef mb) {
   using Section = typename LP::section;
 
   auto *hdr =
       reinterpret_cast<const typename LP::mach_header *>(mb.getBufferStart());
   if (hdr->magic != LP::magic)
     return false;
 
   if (const auto *c =
for (const Section &sec : sectionHeaders) {
            sectname == section_names::swift)) {
         return true;
       }
     }
   }
   return false;
 }
 
-bool macho::hasObjCSection(MemoryBufferRef mb) {
+bool macho::hasObjCSection(WritableMemoryBufferRef mb) {
   if (target->wordSize == 8)
     return ::hasObjCSection<LP64>(mb);
   else
     return ::hasObjCSection<ILP32>(mb);
 }

lld/MachO/Target.h

template <class LP> TargetInfo(LP) {
     headerSize = sizeof(typename LP::mach_header);
     wordSize = LP::wordSize;
   }
 
   virtual ~TargetInfo() = default;
 
   // Validate the relocation structure and get its addend.
   virtual int64_t
-  getEmbeddedAddend(llvm::MemoryBufferRef, uint64_t offset,
+  getEmbeddedAddend(llvm::WritableMemoryBufferRef, uint64_t offset,
                     const llvm::MachO::relocation_info) const = 0;
   virtual void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                            uint64_t relocVA) const = 0;
 
   // Write code for lazy binding. See the comments on StubsSection for more
   // details.
   virtual void writeStub(uint8_t *buf, const Symbol &) const = 0;
   virtual void writeStubHelperHeader(uint8_t *buf) const = 0;

llvm/include/llvm/LTO/Caching.h

 
 namespace llvm {
 namespace lto {
 
 /// This type defines the callback to add a pre-existing native object file
 /// (e.g. in a cache).
 ///
 /// Buffer callbacks must be thread safe.
-using AddBufferFn =
-    std::function<void(unsigned Task, std::unique_ptr<MemoryBuffer> MB)>;
+using AddBufferFn = std::function<void(
+    unsigned Task, std::unique_ptr<WritableMemoryBuffer> MB)>;
 
 /// Create a local file system cache which uses the given cache directory and
 /// file callback. This function also creates the cache directory if it does not
 /// already exist.
 Expected<NativeObjectCache> localCache(StringRef CacheDirectoryPath,
                                        AddBufferFn AddBuffer);
 
 } // namespace lto
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/MemoryBuffer.h

public:
   getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "");
 
   /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note
   /// that the caller need not initialize the memory allocated by this method.
   /// The memory is owned by the MemoryBuffer object.
   static std::unique_ptr<WritableMemoryBuffer>
   getNewMemBuffer(size_t Size, const Twine &BufferName = "");
 
+  /// Open the specified memory range as a MemoryBuffer, copying the contents
+  /// and taking ownership of it. InputData does not have to be null terminated.
+  static std::unique_ptr<WritableMemoryBuffer>
+  getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");
+
+  static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+  getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
+              bool RequiresNullTerminator = true, bool IsVolatile = false);
+
 private:
   // Hide these base class factory function so one can't write
   //   WritableMemoryBuffer::getXXX()
   // and be surprised that he got a read-only Buffer.
   using MemoryBuffer::getFileAsStream;
   using MemoryBuffer::getFileOrSTDIN;
   using MemoryBuffer::getMemBuffer;
-  using MemoryBuffer::getMemBufferCopy;
-  using MemoryBuffer::getOpenFile;
   using MemoryBuffer::getOpenFileSlice;
   using MemoryBuffer::getSTDIN;
 };
 
 /// This class is an extension of MemoryBuffer, which allows write access to
 /// the underlying contents and committing those changes to the original source.
 /// It only supports creation methods that are guaranteed to produce a writable
 /// buffer.  For example, mapping a file read-only is not supported.

llvm/include/llvm/Support/MemoryBufferRef.h

 //===- MemoryBufferRef.h - Memory Buffer Reference --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the MemoryBuffer interface.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MEMORYBUFFERREF_H
 #define LLVM_SUPPORT_MEMORYBUFFERREF_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 class MemoryBuffer;
+class WritableMemoryBuffer;
+class WritableMemoryBufferRef;
 
 class MemoryBufferRef {
+protected:
   StringRef Buffer;
   StringRef Identifier;
 
 public:
   MemoryBufferRef() = default;
   MemoryBufferRef(const MemoryBuffer &Buffer);
   MemoryBufferRef(StringRef Buffer, StringRef Identifier)
       : Buffer(Buffer), Identifier(Identifier) {}
 
   StringRef getBuffer() const { return Buffer; }
   StringRef getBufferIdentifier() const { return Identifier; }
 
   const char *getBufferStart() const { return Buffer.begin(); }
   const char *getBufferEnd() const { return Buffer.end(); }
   size_t getBufferSize() const { return Buffer.size(); }
+  // This operation is safe iff this MemoryBufferRef was initialized with a
+  // writable buffer.
+  WritableMemoryBufferRef castToWritable() const;
 
   /// Check pointer identity (not value) of identifier and data.
   friend bool operator==(const MemoryBufferRef &LHS,
                          const MemoryBufferRef &RHS) {
     return LHS.Buffer.begin() == RHS.Buffer.begin() &&
            LHS.Buffer.end() == RHS.Buffer.end() &&
            LHS.Identifier.begin() == RHS.Identifier.begin() &&
            LHS.Identifier.end() == RHS.Identifier.end();
   }
 
   friend bool operator!=(const MemoryBufferRef &LHS,
                          const MemoryBufferRef &RHS) {
     return !(LHS == RHS);
   }
 };
 
+class WritableMemoryBufferRef : public MemoryBufferRef {
+public:
+  WritableMemoryBufferRef() = default;
+  WritableMemoryBufferRef(const WritableMemoryBuffer &Buffer);
+  WritableMemoryBufferRef(MutableArrayRef<char> Buffer, StringRef Identifier)
+      : MemoryBufferRef({Buffer.data(), Buffer.size()}, Identifier) {}
+
+  // const_cast is well-defined here, because the underlying buffer is
+  // guaranteed to have been initialized with a mutable buffer.
+  char *getBufferStart() const { return const_cast<char *>(Buffer.begin()); }
+  char *getBufferEnd() const { return const_cast<char *>(Buffer.end()); }
+};
+
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_MEMORYBUFFERREF_H

llvm/lib/LTO/Caching.cpp

return [=](unsigned Task, StringRef Key) -> AddStreamFn {
     SmallString<64> EntryPath;
     sys::path::append(EntryPath, CacheDirectoryPath, "llvmcache-" + Key);
     // First, see if we have a cache hit.
     SmallString<64> ResultPath;
     Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
         Twine(EntryPath), sys::fs::OF_UpdateAtime, &ResultPath);
     std::error_code EC;
     if (FDOrErr) {
-      ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-          MemoryBuffer::getOpenFile(*FDOrErr, EntryPath,
+      ErrorOr<std::unique_ptr<WritableMemoryBuffer>> MBOrErr =
+          WritableMemoryBuffer::getOpenFile(*FDOrErr, EntryPath,
                                             /*FileSize=*/-1,
                                             /*RequiresNullTerminator=*/false);
       sys::fs::closeFile(*FDOrErr);
       if (MBOrErr) {
         AddBuffer(Task, std::move(*MBOrErr));
         return AddStreamFn();
       }
       EC = MBOrErr.getError();
     } else {
       EC = errorToErrorCode(FDOrErr.takeError());
struct CacheStream : NativeObjectStream {
             TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
             Task(Task) {}
 
       ~CacheStream() {
         // Make sure the stream is closed before committing it.
         OS.reset();
 
         // Open the file first to avoid racing with a cache pruner.
-        ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-            MemoryBuffer::getOpenFile(
+        ErrorOr<std::unique_ptr<WritableMemoryBuffer>> MBOrErr =
+            WritableMemoryBuffer::getOpenFile(
                 sys::fs::convertFDToNativeFile(TempFile.FD), TempFile.TmpName,
                 /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
         if (!MBOrErr)
           report_fatal_error(Twine("Failed to open new cache file ") +
                              TempFile.TmpName + ": " +
                              MBOrErr.getError().message() + "\n");
 
         // On POSIX systems, this will atomically replace the destination if
         // it already exists. We try to emulate this on Windows, but this may
         // fail with a permission denied error (for example, if the destination
         // is currently opened by another process that does not give us the
         // sharing permissions we need). Since the existing file should be
         // semantically equivalent to the one we are trying to write, we give
         // AddBuffer a copy of the bytes we wrote in that case. We do this
         // instead of just using the existing file, because the pruner might
         // delete the file before we get a chance to use it.
         Error E = TempFile.keep(EntryPath);
         E = handleErrors(std::move(E), [&](const ECError &E) -> Error {
           std::error_code EC = E.convertToErrorCode();
           if (EC != errc::permission_denied)
             return errorCodeToError(EC);
 
-          auto MBCopy = MemoryBuffer::getMemBufferCopy((*MBOrErr)->getBuffer(),
-                                                       EntryPath);
+          MutableArrayRef<char> buf = (*MBOrErr)->getBuffer();
+          auto MBCopy = WritableMemoryBuffer::getMemBufferCopy(
+              {buf.data(), buf.size()}, EntryPath);
           MBOrErr = std::move(MBCopy);
 
           // FIXME: should we consume the discard error?
           consumeError(TempFile.discard());
 
           return Error::success();
         });
 

llvm/lib/Object/Archive.cpp

if (!isThin) {
     if (!Size)
       return Size.takeError();
     return StringRef(Data.data() + StartOfFile, Size.get());
   }
   Expected<std::string> FullNameOrErr = getFullName();
   if (!FullNameOrErr)
     return FullNameOrErr.takeError();
   const std::string &FullName = *FullNameOrErr;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(FullName);
+  // Create a writable buffer in case our caller wants to cast our return value
+  // into a WritableMemoryBuffer. (Such a cast would be safe iff this Archive
+  // was initialized with a WritableMemoryBuffer too.)
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
+      WritableMemoryBuffer::getFile(FullName);
   if (std::error_code EC = Buf.getError())
     return errorCodeToError(EC);
   Parent->ThinBuffers.push_back(std::move(*Buf));
   return Parent->ThinBuffers.back()->getBuffer();
 }
 
 Expected<Archive::Child> Archive::Child::getNext() const {
   size_t SpaceToSkip = Data.size();

llvm/lib/Support/MemoryBuffer.cpp

getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
   memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
   return std::move(Buf);
 }
 
 std::unique_ptr<MemoryBuffer>
 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
   auto Buf = getMemBufferCopyImpl(InputData, BufferName);
   if (Buf)
+    return std::unique_ptr<MemoryBuffer>(std::move(*Buf));
+  return nullptr;
+}
+
+std::unique_ptr<WritableMemoryBuffer>
+WritableMemoryBuffer::getMemBufferCopy(StringRef InputData,
+                                       const Twine &BufferName) {
+  auto Buf = getMemBufferCopyImpl(InputData, BufferName);
+  if (Buf)
     return std::move(*Buf);
   return nullptr;
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
                              bool RequiresNullTerminator) {
   SmallString<256> NameBuf;

 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
                           bool RequiresNullTerminator, bool IsVolatile) {
   return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
                          RequiresNullTerminator, IsVolatile);
 }
 
+ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
+WritableMemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename,
+                                  uint64_t FileSize,
+                                  bool RequiresNullTerminator,
+                                  bool IsVolatile) {
+  return getOpenFileImpl<WritableMemoryBuffer>(
+      FD, Filename, FileSize, FileSize, 0, RequiresNullTerminator, IsVolatile);
+}
+
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
                                int64_t Offset, bool IsVolatile) {
   assert(MapSize != uint64_t(-1));
   return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
                                        IsVolatile);
 }
 

llvm/lib/Support/MemoryBufferRef.cpp

 
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 
 MemoryBufferRef::MemoryBufferRef(const MemoryBuffer &Buffer)
     : Buffer(Buffer.getBuffer()), Identifier(Buffer.getBufferIdentifier()) {}
+
+WritableMemoryBufferRef MemoryBufferRef::castToWritable() const {
+  return WritableMemoryBufferRef(
+      MutableArrayRef<char>(const_cast<char *>(Buffer.data()), Buffer.size()),
+      Identifier);
+}
+
+WritableMemoryBufferRef::WritableMemoryBufferRef(
+    const WritableMemoryBuffer &Buffer)
+    : MemoryBufferRef(Buffer) {}