SourceManager: Prefer Optional<MemoryBufferRef> over MemoryBuffer*

[dexonsmith]

Summary

Change the APIs in SourceManager returning const MemoryBuffer* to
return Optional<MemoryBufferRef> instead, and remove the `bool
*Invalid` flag from same. This removes the need to create dummy
invalid buffers in SrcMgr::ContentCache and clarifies buffer ownership.

A few APIs changed, and a few were added.

• SrcMgr::ContentCache::getBuffer returns Optional<MemoryBufferRef>.
• SrcMgr::ContentCache::getBufferIdentifier returns Optional<StringRef>.
• SrcMgr::ContentCache::getBufferSize returns Optional<unsigned>.
• SourceManager::getMemoryBufferForFile returns Optional<MemoryBufferRef>.
• SourceManager::getBuffer returns Optional<MemoryBufferRef>.
• SourceManager::getBufferOrFake returns MemoryBufferRef, replacing None with fake data.
• SourceManager::getBufferIdentifier returns Optional<StringRef>.
• SourceManager::getBufferIdentifierOrEmpty returns StringRef, replacing None with "".
• SourceManager::getBufferDataOrNone returns Optional<StringRef>

SourceManager::getBufferData did not change to return
Optional<StringRef> because its usage is too pervasive. A possible
follow-up would be to add SourceManager::getBufferDataOrFake (to match
the other APIs) and move components over but I'm not sure it's urgent.

Threading MemoryBufferRef (instead of const MemoryBuffer*) through had
a few small side effects:

• FrontendInputFile now stores a MemoryBufferRef.
• SourceManager::createFileID now takes a MemoryBufferRef.
• llvm::line_iterator now uses an Optional<StringRef>.
• MemoryBufferRef::operator== now exists and compares pointer identity for comparing Optional<MemoryBufferRef>.

[dexonsmith]

This appears to be a duplicate of https://reviews.llvm.org/D66782. Abandon the newer copy.

clang-tools-extra/clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp

void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
   const bool IsIfStmt = isa<IfStmt>(Statement);
 
   if (!IsIfStmt &&
       SM.getSpellingLineNumber(Token.getLocation()) != SemicolonLine)
     return;
 
   SourceLocation LocEnd = Semicolon->getEndLoc();
   FileID FID = SM.getFileID(LocEnd);
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, LocEnd);
+  llvm::MemoryBufferRef Buffer = SM.getBufferOrFake(FID, LocEnd);
   Lexer Lexer(SM.getLocForStartOfFile(FID), Ctxt.getLangOpts(),
-              Buffer->getBufferStart(), SM.getCharacterData(LocEnd) + 1,
-              Buffer->getBufferEnd());
+              Buffer.getBufferStart(), SM.getCharacterData(LocEnd) + 1,
+              Buffer.getBufferEnd());
   if (Lexer.LexFromRawLexer(Token))
     return;
 
   unsigned BaseIndent = SM.getSpellingColumnNumber(Statement->getBeginLoc());
   unsigned NewTokenIndent = SM.getSpellingColumnNumber(Token.getLocation());
   unsigned NewTokenLine = SM.getSpellingLineNumber(Token.getLocation());
 
   if (!IsIfStmt && NewTokenIndent <= BaseIndent &&

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

diag(AssertLoc, "found assert() that could be replaced by static_assert()")
       << FixItHints;
 }
 
 SourceLocation StaticAssertCheck::getLastParenLoc(const ASTContext *ASTCtx,
                                                   SourceLocation AssertLoc) {
   const LangOptions &Opts = ASTCtx->getLangOpts();
   const SourceManager &SM = ASTCtx->getSourceManager();
 
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getFileID(AssertLoc));
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      SM.getBuffer(SM.getFileID(AssertLoc));
   if (!Buffer)
     return SourceLocation();
 
   const char *BufferPos = SM.getCharacterData(AssertLoc);
 
   Token Token;
   Lexer Lexer(SM.getLocForStartOfFile(SM.getFileID(AssertLoc)), Opts,
               Buffer->getBufferStart(), BufferPos, Buffer->getBufferEnd());

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.cpp

 
 bool MagicNumbersCheck::isSyntheticValue(const SourceManager *SourceManager,
                                          const IntegerLiteral *Literal) const {
   const std::pair<FileID, unsigned> FileOffset =
       SourceManager->getDecomposedLoc(Literal->getLocation());
   if (FileOffset.first.isInvalid())
     return false;
 
-  const StringRef BufferIdentifier =
-      SourceManager->getBuffer(FileOffset.first)->getBufferIdentifier();
-
-  return BufferIdentifier.empty();
+  return SourceManager->getBufferIdentifierOrEmpty(FileOffset.first).empty();
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clangd/ClangdUnit.cpp

private:
   //   ... main file contents ...
   //
   // When using a preamble, the "header1" and "header2" subtrees get skipped.
   // We insert them right after the built-in header, which still appears.
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind Kind, FileID PrevFID) override {
     // It'd be nice if there was a better way to identify built-in headers...
     if (Reason == FileChangeReason::ExitFile &&
-        SM.getBuffer(PrevFID)->getBufferIdentifier() == "<built-in>")
+        SM.getBufferOrFake(PrevFID)->getBufferIdentifier() == "<built-in>")
       replay();
   }
 
   void replay() {
     for (const auto &Inc : Includes.MainFileIncludes) {
       const FileEntry *File = nullptr;
       if (Inc.Resolved != "")
         if (auto FE = SM.getFileManager().getFile(Inc.Resolved))

clang-tools-extra/clangd/Format.cpp

 /// Append closing brackets )]} to \p Code to make it well-formed.
 /// Clang-format conservatively refuses to format files with unmatched brackets
 /// as it isn't sure where the errors are and so can't correct.
 /// When editing, it's reasonable to assume code before the cursor is complete.
 void closeBrackets(std::string &Code, const format::FormatStyle &Style) {
   SourceManagerForFile FileSM("dummy.cpp", Code);
   auto &SM = FileSM.get();
   FileID FID = SM.getMainFileID();
-  Lexer Lex(FID, SM.getBuffer(FID), SM, format::getFormattingLangOpts(Style));
+  Lexer Lex(FID, SM.getBufferOrFake(FID), SM,
+            format::getFormattingLangOpts(Style));
   Token Tok;
   std::vector<char> Brackets;
   while (!Lex.LexFromRawLexer(Tok)) {
     switch(Tok.getKind()) {
       case tok::l_paren:
         Brackets.push_back(')');
         break;
       case tok::l_brace:

clang-tools-extra/clangd/SourceCode.cpp

llvm::Optional<SourceRange> toHalfOpenFileRange(const SourceManager &SM,
   if (!isValidFileRange(SM, Result))
     return llvm::None;
 
   return Result;
 }
 
 llvm::StringRef toSourceCode(const SourceManager &SM, SourceRange R) {
   assert(isValidFileRange(SM, R));
-  bool Invalid = false;
-  auto *Buf = SM.getBuffer(SM.getFileID(R.getBegin()), &Invalid);
-  assert(!Invalid);
+  llvm::Optional<llvm::MemoryBufferRef> Buf =
+      SM.getBuffer(SM.getFileID(R.getBegin()));
+  assert(Buf);
 
   size_t BeginOffset = SM.getFileOffset(R.getBegin());
   size_t EndOffset = SM.getFileOffset(R.getEnd());
   return Buf->getBuffer().substr(BeginOffset, EndOffset - BeginOffset);
 }
 
 llvm::Expected<SourceLocation> sourceLocationInMainFile(const SourceManager &SM,
                                                         Position P) {
-  llvm::StringRef Code = SM.getBuffer(SM.getMainFileID())->getBuffer();
+  llvm::StringRef Code = SM.getBufferOrFake(SM.getMainFileID())->getBuffer();
   auto Offset =
       positionToOffset(Code, P, /*AllowColumnBeyondLineLength=*/false);
   if (!Offset)
     return Offset.takeError();
   return SM.getLocForStartOfFile(SM.getMainFileID()).getLocWithOffset(*Offset);
 }
 
 Range halfOpenToRange(const SourceManager &SM, CharSourceRange R) {

 template <typename Action>
 static void lex(llvm::StringRef Code, const format::FormatStyle &Style,
                 Action A) {
   // FIXME: InMemoryFileAdapter crashes unless the buffer is null terminated!
   std::string NullTerminatedCode = Code.str();
   SourceManagerForFile FileSM("dummy.cpp", NullTerminatedCode);
   auto &SM = FileSM.get();
   auto FID = SM.getMainFileID();
-  Lexer Lex(FID, SM.getBuffer(FID), SM, format::getFormattingLangOpts(Style));
+  Lexer Lex(FID, SM.getBufferOrFake(FID), SM,
+            format::getFormattingLangOpts(Style));
   Token Tok;
 
   while (!Lex.LexFromRawLexer(Tok))
     A(Tok);
 }
 
 llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,
                                              const format::FormatStyle &Style) {

clang-tools-extra/modularize/PreprocessorTracker.cpp

static std::string getSourceString(clang::Preprocessor &PP,
   const char *EndPtr = PP.getSourceManager().getCharacterData(EndLoc);
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).trim().str();
 }
 
 // Retrieve source line from file image given a location.
 static std::string getSourceLine(clang::Preprocessor &PP,
                                  clang::SourceLocation Loc) {
-  const llvm::MemoryBuffer *MemBuffer =
-      PP.getSourceManager().getBuffer(PP.getSourceManager().getFileID(Loc));
+  llvm::MemoryBufferRef MemBuffer = PP.getSourceManager().getBufferOrFake(
+      PP.getSourceManager().getFileID(Loc));
   const char *Buffer = MemBuffer->getBufferStart();
   const char *BufferEnd = MemBuffer->getBufferEnd();
   const char *BeginPtr = PP.getSourceManager().getCharacterData(Loc);
   const char *EndPtr = BeginPtr;
   while (BeginPtr > Buffer) {
     if (*BeginPtr == '\n') {
       BeginPtr++;
       break;
     }
     BeginPtr--;
   }
   while (EndPtr < BufferEnd) {
     if (*EndPtr == '\n') {
       break;
     }
     EndPtr++;
   }
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).str();
 }
 
 // Retrieve source line from file image given a file ID and line number.
 static std::string getSourceLine(clang::Preprocessor &PP, clang::FileID FileID,
                                  int Line) {
-  const llvm::MemoryBuffer *MemBuffer = PP.getSourceManager().getBuffer(FileID);
+  llvm::MemoryBufferRef MemBuffer =
+      PP.getSourceManager().getBufferOrFake(FileID);
   const char *Buffer = MemBuffer->getBufferStart();
   const char *BufferEnd = MemBuffer->getBufferEnd();
   const char *BeginPtr = Buffer;
   const char *EndPtr = BufferEnd;
   int LineCounter = 1;
   if (Line == 1)
     BeginPtr = Buffer;
   else {

clang/include/clang/Basic/SourceManager.h

inline bool isModuleMap(CharacteristicKind CK) {
     return CK == C_User_ModuleMap || CK == C_System_ModuleMap;
   }
 
   /// One instance of this struct is kept for every file loaded or used.
   ///
   /// This object owns the MemoryBuffer object.
   class alignas(8) ContentCache {
     enum CCFlags {
-      /// Whether the buffer is invalid.
-      InvalidFlag = 0x01,
-
       /// Whether the buffer should not be freed on destruction.
       DoNotFreeFlag = 0x02
     };
 
     /// The actual buffer containing the characters from the input
     /// file.
     ///
     /// This is owned by the ContentCache object.  The bits indicate
public:
     /// considered to be volatile (likely to change between stat and open).
     unsigned IsFileVolatile : 1;
 
     /// True if this file may be transient, that is, if it might not
     /// exist at some later point in time when this content entry is used,
     /// after serialization and deserialization.
     unsigned IsTransient : 1;
 
+    /// Cache whether the content is known to be invalid.
+    mutable unsigned IsBufferInvalid : 1;
+
     ContentCache(const FileEntry *Ent = nullptr) : ContentCache(Ent, Ent) {}
 
     ContentCache(const FileEntry *Ent, const FileEntry *contentEnt)
         : Buffer(nullptr, false), OrigEntry(Ent), ContentsEntry(contentEnt),
-          BufferOverridden(false), IsFileVolatile(false), IsTransient(false) {}
+          BufferOverridden(false), IsFileVolatile(false), IsTransient(false),
+          IsBufferInvalid(false) {}
 
     /// The copy ctor does not allow copies where source object has either
     /// a non-NULL Buffer or SourceLineCache.  Ownership of allocated memory
     /// is not transferred, so this is a logical error.
     ContentCache(const ContentCache &RHS)
-        : Buffer(nullptr, false), BufferOverridden(false),
-          IsFileVolatile(false), IsTransient(false) {
-      OrigEntry = RHS.OrigEntry;
-      ContentsEntry = RHS.ContentsEntry;
-
+        : ContentCache(RHS.OrigEntry, RHS.ContentsEntry) {
       assert(RHS.Buffer.getPointer() == nullptr &&
              RHS.SourceLineCache == nullptr &&
              "Passed ContentCache object cannot own a buffer.");
 
       NumLines = RHS.NumLines;
     }
 
     ContentCache &operator=(const ContentCache& RHS) = delete;
 
     ~ContentCache();
 
     /// Returns the memory buffer for the associated content.
     ///
     /// \param Diag Object through which diagnostics will be emitted if the
     ///   buffer cannot be retrieved.
     ///
     /// \param Loc If specified, is the location that invalid file diagnostics
     ///   will be emitted at.
     ///
     /// \param Invalid If non-NULL, will be set \c true if an error occurred.
-    const llvm::MemoryBuffer *getBuffer(DiagnosticsEngine &Diag,
-                                        FileManager &FM,
-                                        SourceLocation Loc = SourceLocation(),
-                                        bool *Invalid = nullptr) const;
+    llvm::Optional<llvm::MemoryBufferRef>
+    getBuffer(DiagnosticsEngine &Diag, FileManager &FM,
+              SourceLocation Loc = SourceLocation()) const;
+
+    llvm::Optional<llvm::StringRef>
+    getBufferIdentifier(DiagnosticsEngine &Diag, FileManager &FM,
+                        SourceLocation Loc = SourceLocation()) const {
+      if (auto Buffer = getBuffer(Diag, FM, Loc))
+        return Buffer->getBufferIdentifier();
+      return None;
+    }
+
+    /// Get the buffer size, giving 0 if the buffer is invalid.
+    llvm::Optional<unsigned>
+    getBufferSize(DiagnosticsEngine &Diag, FileManager &FM,
+                  SourceLocation Loc = SourceLocation()) const {
+      if (auto Buffer = getBuffer(Diag, FM, Loc))
+        return Buffer->getBufferSize();
+      return None;
+    }
 
     /// Returns the size of the content encapsulated by this
     /// ContentCache.
     ///
     /// This can be the size of the source file or the size of an
     /// arbitrary scratch buffer.  If the ContentCache encapsulates a source
     /// file this size is retrieved from the file's FileEntry.
     unsigned getSize() const;
const llvm::MemoryBuffer *getRawBuffer() const {
       return Buffer.getPointer();
     }
 
     /// Replace the existing buffer (which will be deleted)
     /// with the given buffer.
     void replaceBuffer(const llvm::MemoryBuffer *B, bool DoNotFree = false);
 
     /// Determine whether the buffer itself is invalid.
-    bool isBufferInvalid() const {
-      return Buffer.getInt() & InvalidFlag;
-    }
+    bool isBufferInvalid() const { return IsBufferInvalid; }
 
     /// Determine whether the buffer should be freed.
     bool shouldFreeBuffer() const {
       return (Buffer.getInt() & DoNotFreeFlag) == 0;
     }
   };
 
   // Assert that the \c ContentCache objects will always be 8-byte aligned so
static FileInfo get(SourceLocation IL, const ContentCache *Con,
       X.NumCreatedFIDs = 0;
       X.HasLineDirectives = false;
       X.ContentAndKind.setPointer(Con);
       X.ContentAndKind.setInt(FileCharacter);
       X.Filename = Filename;
       return X;
     }
 
+    static FileInfo getForRecovery() {
+      FileInfo X = get(SourceLocation(), nullptr, SrcMgr::C_User, "");
+      return X;
+    }
+
     SourceLocation getIncludeLoc() const {
       return SourceLocation::getFromRawEncoding(IncludeLoc);
     }
 
     const ContentCache *getContentCache() const {
       return ContentAndKind.getPointer();
     }
 
FileID createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                       int LoadedID = 0, unsigned LoadedOffset = 0,
                       SourceLocation IncludeLoc = SourceLocation()) {
     StringRef Name = Buffer->getBufferIdentifier();
     return createFileID(
         createMemBufferContentCache(Buffer.release(), /*DoNotFree*/ false),
         Name, IncludeLoc, FileCharacter, LoadedID, LoadedOffset);
   }
 
-  enum UnownedTag { Unowned };
-
   /// Create a new FileID that represents the specified memory buffer.
   ///
-  /// This does not take ownership of the MemoryBuffer. The memory buffer must
-  /// outlive the SourceManager.
-  FileID createFileID(UnownedTag, const llvm::MemoryBuffer *Buffer,
+  /// This does not take ownership of the MemoryBufferRef. The memory buffer
+  /// must outlive the SourceManager.
+  FileID createFileID(llvm::MemoryBufferRef Buffer,
                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
                       int LoadedID = 0, unsigned LoadedOffset = 0,
                       SourceLocation IncludeLoc = SourceLocation()) {
-    return createFileID(createMemBufferContentCache(Buffer, /*DoNotFree*/ true),
-                        Buffer->getBufferIdentifier(), IncludeLoc,
-                        FileCharacter, LoadedID, LoadedOffset);
+    return createFileID(llvm::MemoryBuffer::getMemBuffer(Buffer), FileCharacter,
+                        LoadedID, LoadedOffset, IncludeLoc);
   }
 
   /// Get the FileID for \p SourceFile if it exists. Otherwise, create a
   /// new FileID for the \p SourceFile.
   FileID getOrCreateFileID(const FileEntry *SourceFile,
                            SrcMgr::CharacteristicKind FileCharacter) {
     FileID ID = translateFile(SourceFile);
     return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
public:
   SourceLocation createTokenSplitLoc(SourceLocation SpellingLoc,
                                      SourceLocation TokenStart,
                                      SourceLocation TokenEnd);
 
   /// Retrieve the memory buffer associated with the given file.
   ///
   /// \param Invalid If non-NULL, will be set \c true if an error
   /// occurs while retrieving the memory buffer.
-  const llvm::MemoryBuffer *getMemoryBufferForFile(const FileEntry *File,
-                                                   bool *Invalid = nullptr);
+  llvm::Optional<llvm::MemoryBufferRef>
+  getMemoryBufferForFile(const FileEntry *File);
 
   /// Override the contents of the given source file by providing an
   /// already-allocated buffer.
   ///
   /// \param SourceFile the source file whose contents will be overridden.
   ///
   /// \param Buffer the memory buffer whose contents will be used as the
   /// data in the given source file.
public:
   //===--------------------------------------------------------------------===//
   // FileID manipulation methods.
   //===--------------------------------------------------------------------===//
 
   /// Return the buffer for the specified FileID.
   ///
   /// If there is an error opening this buffer the first time, this
   /// manufactures a temporary buffer and returns a non-empty error string.
-  const llvm::MemoryBuffer *getBuffer(FileID FID, SourceLocation Loc,
-                                      bool *Invalid = nullptr) const {
+  llvm::Optional<llvm::MemoryBufferRef>
+  getBuffer(FileID FID, SourceLocation Loc = SourceLocation()) const {
     bool MyInvalid = false;
     const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
-    if (MyInvalid || !Entry.isFile()) {
-      if (Invalid)
-        *Invalid = true;
-
-      return getFakeBufferForRecovery();
-    }
+    if (MyInvalid || !Entry.isFile())
+      return None;
 
     return Entry.getFile().getContentCache()->getBuffer(Diag, getFileManager(),
-                                                        Loc, Invalid);
+                                                        Loc);
   }
 
-  const llvm::MemoryBuffer *getBuffer(FileID FID,
-                                      bool *Invalid = nullptr) const {
-    bool MyInvalid = false;
-    const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
-    if (MyInvalid || !Entry.isFile()) {
-      if (Invalid)
-        *Invalid = true;
+  llvm::MemoryBufferRef
+  getBufferOrFake(FileID FID, SourceLocation Loc = SourceLocation()) const {
+    if (auto Buffer = getBuffer(FID, Loc))
+      return *Buffer;
+    return llvm::MemoryBufferRef("<<<INVALID BUFFER>>>", "");
+  }
 
-      return getFakeBufferForRecovery();
-    }
+  llvm::Optional<llvm::StringRef>
+  getBufferIdentifier(FileID FID, SourceLocation Loc = SourceLocation()) const {
+    if (auto Buffer = getBuffer(FID, Loc))
+      return Buffer->getBufferIdentifier();
+    return None;
 
-    return Entry.getFile().getContentCache()->getBuffer(
-        Diag, getFileManager(), SourceLocation(), Invalid);
+  llvm::StringRef
+  getBufferIdentifierOrEmpty(FileID FID,
+                             SourceLocation Loc = SourceLocation()) const {
+    if (auto Identifier = getBufferIdentifier(FID, Loc))
+      return *Identifier;
+    return "";
   }
 
   /// Returns the FileEntry record for the provided FileID.
   const FileEntry *getFileEntryForID(FileID FID) const {
     bool MyInvalid = false;
     const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
     if (MyInvalid || !Entry.isFile())
       return nullptr;
public:
   {
     const SrcMgr::ContentCache *Content = sloc.getFile().getContentCache();
     if (!Content)
       return nullptr;
     return Content->OrigEntry;
   }
 
   /// Return a StringRef to the source buffer data for the
+  /// specified FileID, or None if it's invalid.
+  ///
+  /// \param FID The file ID whose contents will be returned.
+  llvm::Optional<StringRef> getBufferDataOrNone(FileID FID) const;
+
+  /// Return a StringRef to the source buffer data for the
   /// specified FileID.
   ///
   /// \param FID The file ID whose contents will be returned.
   /// \param Invalid If non-NULL, will be set true if an error occurred.
-  StringRef getBufferData(FileID FID, bool *Invalid = nullptr) const;
+  StringRef getBufferData(FileID FID, bool *Invalid) const {
+    auto Data = getBufferDataOrNone(FID);
+    if (Invalid)
+      *Invalid = !Data;
+    return Data ? *Data : "";
+  }
+
+  StringRef getBufferData(FileID FID) const {
+    if (auto Data = getBufferDataOrNone(FID))
+      return *Data;
+    return "";
+  }
 
   /// Get the number of FileIDs (files and macros) that were created
   /// during preprocessing of \p FID, including it.
   unsigned getNumCreatedFIDsForFileID(FileID FID) const {
     bool Invalid = false;
     const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
     if (Invalid || !Entry.isFile())
       return 0;

 
   /// \return Location of the top-level macro caller.
   SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const;
 
 private:
   friend class ASTReader;
   friend class ASTWriter;
 
-  llvm::MemoryBuffer *getFakeBufferForRecovery() const;
   const SrcMgr::ContentCache *getFakeContentCacheForRecovery() const;
 
   const SrcMgr::SLocEntry &loadSLocEntry(unsigned Index, bool *Invalid) const;
 
   /// Get the entry with the given unwrapped FileID.
   const SrcMgr::SLocEntry &getSLocEntryByID(int ID,
                                             bool *Invalid = nullptr) const {
     assert(ID != -1 && "Using FileID sentinel value");

clang/include/clang/Frontend/FrontendAction.h

StringRef getCurrentFile() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.getFile();
   }
 
   StringRef getCurrentFileOrBufferName() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.isFile()
                ? CurrentInput.getFile()
-               : CurrentInput.getBuffer()->getBufferIdentifier();
+               : CurrentInput.getBuffer().getBufferIdentifier();
   }
 
   InputKind getCurrentFileKind() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.getKind();
   }
 
   ASTUnit &getCurrentASTUnit() const {

clang/include/clang/Frontend/FrontendOptions.h

 #define LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
 
 #include "clang/AST/ASTDumperUtils.h"
 #include "clang/Basic/LangStandard.h"
 #include "clang/Frontend/CommandLineSourceLoc.h"
 #include "clang/Sema/CodeCompleteOptions.h"
 #include "clang/Serialization/ModuleFileExtension.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-namespace llvm {
-
-class MemoryBuffer;
-
-} // namespace llvm
-
 namespace clang {
 
 namespace frontend {
 
 enum ActionKind {
   /// Parse ASTs and list Decl nodes.
   ASTDeclList,
 

 /// An input file for the front end.
 class FrontendInputFile {
   /// The file name, or "-" to read from standard input.
   std::string File;
 
   /// The input, if it comes from a buffer rather than a file. This object
   /// does not own the buffer, and the caller is responsible for ensuring
   /// that it outlives any users.
-  const llvm::MemoryBuffer *Buffer = nullptr;
+  llvm::Optional<llvm::MemoryBufferRef> Buffer;
 
   /// The kind of input, e.g., C source, AST file, LLVM IR.
   InputKind Kind;
 
   /// Whether we're dealing with a 'system' input (vs. a 'user' input).
   bool IsSystem = false;
 
 public:
   FrontendInputFile() = default;
   FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
       : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
-  FrontendInputFile(const llvm::MemoryBuffer *Buffer, InputKind Kind,
+  FrontendInputFile(llvm::MemoryBufferRef Buffer, InputKind Kind,
                     bool IsSystem = false)
       : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
 
   InputKind getKind() const { return Kind; }
   bool isSystem() const { return IsSystem; }
 
-  bool isEmpty() const { return File.empty() && Buffer == nullptr; }
-  bool isFile() const { return !isBuffer(); }
-  bool isBuffer() const { return Buffer != nullptr; }
+  bool isEmpty() const { return File.empty() && !Buffer; }
+  bool isFile() const { return !Buffer; }
+  bool isBuffer() const { return !isFile(); }
   bool isPreprocessed() const { return Kind.isPreprocessed(); }
 
   StringRef getFile() const {
     assert(isFile());
     return File;
   }
 
-  const llvm::MemoryBuffer *getBuffer() const {
-    assert(isBuffer());
-    return Buffer;
+  llvm::MemoryBufferRef getBuffer() const {
+    assert(Buffer);
+    return *Buffer;
   }
 };
 
 /// FrontendOptions - Options for controlling the behavior of the frontend.
 class FrontendOptions {
 public:
   /// Disable memory freeing on exit.
   unsigned DisableFree : 1;

clang/include/clang/Frontend/PrecompiledPreamble.h

struct PreambleFileHash {
 
     /// Memory buffers have MD5 instead of modification time.  We don't
     /// compute MD5 for on-disk files because we hope that modification time is
     /// enough to tell if the file was changed.
     llvm::MD5::MD5Result MD5 = {};
 
     static PreambleFileHash createForFile(off_t Size, time_t ModTime);
     static PreambleFileHash
-    createForMemoryBuffer(const llvm::MemoryBuffer *Buffer);
+    createForMemoryBuffer(llvm::Optional<llvm::MemoryBufferRef> Buffer);
 
     friend bool operator==(const PreambleFileHash &LHS,
                            const PreambleFileHash &RHS) {
       return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime &&
              LHS.MD5 == RHS.MD5;
     }
     friend bool operator!=(const PreambleFileHash &LHS,
                            const PreambleFileHash &RHS) {

clang/include/clang/Lex/Lexer.h

 #include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 
 class MemoryBuffer;
+class MemoryBufferRef;
 
 } // namespace llvm
 
 namespace clang {
 
 class DiagnosticBuilder;
 class Preprocessor;
 class SourceManager;
class Lexer : public PreprocessorLexer {
 
   void InitLexer(const char *BufStart, const char *BufPtr, const char *BufEnd);
 
 public:
   /// Lexer constructor - Create a new lexer object for the specified buffer
   /// with the specified preprocessor managing the lexing process.  This lexer
   /// assumes that the associated file buffer and Preprocessor objects will
   /// outlive it, so it doesn't take ownership of either of them.
-  Lexer(FileID FID, const llvm::MemoryBuffer *InputFile, Preprocessor &PP);
+  Lexer(FileID FID, const llvm::MemoryBufferRef &InputFile, Preprocessor &PP);
 
   /// Lexer constructor - Create a new raw lexer object.  This object is only
   /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the
   /// text range will outlive it, so it doesn't take ownership of it.
   Lexer(SourceLocation FileLoc, const LangOptions &LangOpts,
         const char *BufStart, const char *BufPtr, const char *BufEnd);
 
   /// Lexer constructor - Create a new raw lexer object.  This object is only
   /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the
   /// text range will outlive it, so it doesn't take ownership of it.
-  Lexer(FileID FID, const llvm::MemoryBuffer *FromFile,
+  Lexer(FileID FID, const llvm::MemoryBufferRef &FromFile,
         const SourceManager &SM, const LangOptions &LangOpts);
 
   Lexer(const Lexer &) = delete;
   Lexer &operator=(const Lexer &) = delete;
 
   /// Create_PragmaLexer: Lexer constructor - Create a new lexer object for
   /// _Pragma expansion.  This has a variety of magic semantics that this method
   /// sets up.  It returns a new'd Lexer that must be delete'd when done.

clang/lib/ARCMigrate/Transforms.cpp

if (!Lexer::isAtEndOfMacroExpansion(loc, SM, Ctx.getLangOpts(), &loc))
       return SourceLocation();
   }
   loc = Lexer::getLocForEndOfToken(loc, /*Offset=*/0, SM, Ctx.getLangOpts());
 
   // Break down the source location.
   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
 
   // Try to load the file buffer.
-  bool invalidTemp = false;
-  StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
-  if (invalidTemp)
+  llvm::Optional<StringRef> maybeFile = SM.getBufferData(locInfo.first);
+  if (!maybeFile)
     return SourceLocation();
+  StringRef file = *maybeFile;
 
   const char *tokenBegin = file.data() + locInfo.second;
 
   // Lex from the start of the given location.
   Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
               Ctx.getLangOpts(),
               file.begin(), tokenBegin, file.end());
   Token tok;
if (atLoc.isMacroID())
     return false;
 
   SourceManager &SM = Pass.Ctx.getSourceManager();
 
   // Break down the source location.
   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
 
   // Try to load the file buffer.
-  bool invalidTemp = false;
-  StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
-  if (invalidTemp)
+  llvm::Optional<StringRef> maybeFile = SM.getBufferData(locInfo.first);
+  if (!maybeFile)
     return false;
+  StringRef file = *maybeFile;
 
   const char *tokenBegin = file.data() + locInfo.second;
 
   // Lex from the start of the given location.
   Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
               Pass.Ctx.getLangOpts(),
               file.begin(), tokenBegin, file.end());
   Token tok;
if (atLoc.isMacroID())
     return false;
 
   SourceManager &SM = Pass.Ctx.getSourceManager();
 
   // Break down the source location.
   std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
 
   // Try to load the file buffer.
-  bool invalidTemp = false;
-  StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
-  if (invalidTemp)
+  llvm::Optional<StringRef> maybeFile = SM.getBufferData(locInfo.first);
+  if (!maybeFile)
     return false;
+  StringRef file = *maybeFile;
 
   const char *tokenBegin = file.data() + locInfo.second;
 
   // Lex from the start of the given location.
   Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
               Pass.Ctx.getLangOpts(),
               file.begin(), tokenBegin, file.end());
   Token tok;

clang/lib/AST/ASTImporter.cpp

if (!IsBuiltin) {
         if (Entry)
           ToID = ToSM.createFileID(*Entry, *ToIncludeLoc,
                                    FromSLoc.getFile().getFileCharacteristic());
       }
     }
 
     if (ToID.isInvalid() || IsBuiltin) {
       // FIXME: We want to re-use the existing MemoryBuffer!
-      bool Invalid = true;
-      const llvm::MemoryBuffer *FromBuf =
-          Cache->getBuffer(FromContext.getDiagnostics(),
-                           FromSM.getFileManager(), SourceLocation{}, &Invalid);
-      if (!FromBuf || Invalid)
+      llvm::Optional<llvm::MemoryBufferRef> FromBuf = Cache->getBuffer(
+          FromContext.getDiagnostics(), FromSM.getFileManager());
+      if (!FromBuf)
         // FIXME: Use a new error kind?
         return llvm::make_error<ImportError>(ImportError::Unknown);
 
       std::unique_ptr<llvm::MemoryBuffer> ToBuf =
           llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
                                                FromBuf->getBufferIdentifier());
       ToID = ToSM.createFileID(std::move(ToBuf),
                                FromSLoc.getFile().getFileCharacteristic());

clang/lib/Basic/Diagnostic.cpp

for (auto &F : Files) {
     File &File = F.second;
 
     bool PrintedOuterHeading = false;
     auto PrintOuterHeading = [&] {
       if (PrintedOuterHeading) return;
       PrintedOuterHeading = true;
 
       llvm::errs() << "File " << &File << " <FileID " << ID.getHashValue()
-                   << ">: " << SrcMgr.getBuffer(ID)->getBufferIdentifier();
+                   << ">: " << SrcMgr.getBufferOrFake(ID).getBufferIdentifier();
       if (F.second.Parent) {
         std::pair<FileID, unsigned> Decomp =
             SrcMgr.getDecomposedIncludedLoc(ID);
         assert(File.ParentOffset == Decomp.second);
         llvm::errs() << " parent " << File.Parent << " <FileID "
                      << Decomp.first.getHashValue() << "> ";
         SrcMgr.getLocForStartOfFile(Decomp.first)
               .getLocWithOffset(Decomp.second)

clang/lib/Basic/SourceLocation.cpp

 
 const char *FullSourceLoc::getCharacterData(bool *Invalid) const {
   assert(isValid());
   return SrcMgr->getCharacterData(*this, Invalid);
 }
 
 StringRef FullSourceLoc::getBufferData(bool *Invalid) const {
   assert(isValid());
-  return SrcMgr->getBuffer(SrcMgr->getFileID(*this), Invalid)->getBuffer();
+  auto Buffer = SrcMgr->getBuffer(SrcMgr->getFileID(*this));
+  if (Invalid)
+    *Invalid = !Buffer;
+
+  if (Buffer)
+    return Buffer->getBuffer();
+  return "";
 }
 
 std::pair<FileID, unsigned> FullSourceLoc::getDecomposedLoc() const {
   return SrcMgr->getDecomposedLoc(*this);
 }

clang/lib/Basic/SourceManager.cpp

 ///  scratch buffer.  If the ContentCache encapsulates a source file, that
 ///  file is not lazily brought in from disk to satisfy this query.
 unsigned ContentCache::getSize() const {
   return Buffer.getPointer() ? (unsigned) Buffer.getPointer()->getBufferSize()
                              : (unsigned) ContentsEntry->getSize();
 }
 
 void ContentCache::replaceBuffer(const llvm::MemoryBuffer *B, bool DoNotFree) {
+  IsBufferInvalid = false;
+
   if (B && B == Buffer.getPointer()) {
     assert(0 && "Replacing with the same buffer");
     Buffer.setInt(DoNotFree? DoNotFreeFlag : 0);
     return;
   }
 
   if (shouldFreeBuffer())
     delete Buffer.getPointer();
   Buffer.setPointer(B);
   Buffer.setInt((B && DoNotFree) ? DoNotFreeFlag : 0);
 }
 
-const llvm::MemoryBuffer *ContentCache::getBuffer(DiagnosticsEngine &Diag,
-                                                  FileManager &FM,
-                                                  SourceLocation Loc,
-                                                  bool *Invalid) const {
+llvm::Optional<llvm::MemoryBufferRef>
+ContentCache::getBuffer(DiagnosticsEngine &Diag, FileManager &FM,
+                        SourceLocation Loc) const {
   // Lazily create the Buffer for ContentCaches that wrap files.  If we already
   // computed it, just return what we have.
-  if (Buffer.getPointer() || !ContentsEntry) {
-    if (Invalid)
-      *Invalid = isBufferInvalid();
-
-    return Buffer.getPointer();
-  }
+  if (isBufferInvalid())
+    return None;
+  if (auto *B = Buffer.getPointer())
+    return B->getMemBufferRef();
+  if (!ContentsEntry)
+    return None;
 
   // Check that the file's size fits in an 'unsigned' (with room for a
   // past-the-end value). This is deeply regrettable, but various parts of
   // Clang (including elsewhere in this file!) use 'unsigned' to represent file
   // offsets, line numbers, string literal lengths, and so on, and fail
   // miserably on large source files.
   if ((uint64_t)ContentsEntry->getSize() >=
       std::numeric_limits<unsigned>::max()) {
-    // We can't make a memory buffer of the required size, so just make a small
-    // one. We should never hit a situation where we've already parsed to a
-    // later offset of the file, so it shouldn't matter that the buffer is
-    // smaller than the file.
-    Buffer.setPointer(
-        llvm::MemoryBuffer::getMemBuffer("", ContentsEntry->getName())
-            .release());
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_file_too_large,
                                 ContentsEntry->getName());
     else
       Diag.Report(Loc, diag::err_file_too_large)
         << ContentsEntry->getName();
 
-    Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    if (Invalid) *Invalid = true;
-    return Buffer.getPointer();
+    IsBufferInvalid = true;
+    return None;
   }
 
   auto BufferOrError = FM.getBufferForFile(ContentsEntry, IsFileVolatile);
 
   // If we were unable to open the file, then we are in an inconsistent
   // situation where the content cache referenced a file which no longer
   // exists. Most likely, we were using a stat cache with an invalid entry but
   // the file could also have been removed during processing. Since we can't
   // really deal with this situation, just create an empty buffer.
-  //
-  // FIXME: This is definitely not ideal, but our immediate clients can't
-  // currently handle returning a null entry here. Ideally we should detect
-  // that we are in an inconsistent situation and error out as quickly as
-  // possible.
   if (!BufferOrError) {
-    StringRef FillStr("<<<MISSING SOURCE FILE>>>\n");
-    auto BackupBuffer = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(
-        ContentsEntry->getSize(), "<invalid>");
-    char *Ptr = BackupBuffer->getBufferStart();
-    for (unsigned i = 0, e = ContentsEntry->getSize(); i != e; ++i)
-      Ptr[i] = FillStr[i % FillStr.size()];
-    Buffer.setPointer(BackupBuffer.release());
-
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_cannot_open_file,
                                 ContentsEntry->getName(),
                                 BufferOrError.getError().message());
     else
       Diag.Report(Loc, diag::err_cannot_open_file)
           << ContentsEntry->getName() << BufferOrError.getError().message();
 
-    Buffer.setInt(Buffer.getInt() | InvalidFlag);
-
-    if (Invalid) *Invalid = true;
-    return Buffer.getPointer();
+    IsBufferInvalid = true;
+    return None;
   }
 
   Buffer.setPointer(BufferOrError->release());
 
   // Check that the file's size is the same as in the file entry (which may
   // have come from a stat cache).
   if (getRawBuffer()->getBufferSize() != (size_t)ContentsEntry->getSize()) {
     if (Diag.isDiagnosticInFlight())
       Diag.SetDelayedDiagnostic(diag::err_file_modified,
                                 ContentsEntry->getName());
     else
       Diag.Report(Loc, diag::err_file_modified)
         << ContentsEntry->getName();
 
-    Buffer.setInt(Buffer.getInt() | InvalidFlag);
-    if (Invalid) *Invalid = true;
-    return Buffer.getPointer();
+    IsBufferInvalid = true;
+    return None;
   }
 
   // If the buffer is valid, check to see if it has a UTF Byte Order Mark
   // (BOM).  We only support UTF-8 with and without a BOM right now.  See
   // http://en.wikipedia.org/wiki/Byte_order_mark for more information.
   StringRef BufStr = Buffer.getPointer()->getBuffer();
   const char *InvalidBOM = llvm::StringSwitch<const char *>(BufStr)
     .StartsWith(llvm::StringLiteral::withInnerNUL("\x00\x00\xFE\xFF"),
                                                   "UTF-32 (BE)")
     .StartsWith(llvm::StringLiteral::withInnerNUL("\xFF\xFE\x00\x00"),
                                                   "UTF-32 (LE)")
     .StartsWith("\xFE\xFF", "UTF-16 (BE)")
     .StartsWith("\xFF\xFE", "UTF-16 (LE)")
     .StartsWith("\x2B\x2F\x76", "UTF-7")
     .StartsWith("\xF7\x64\x4C", "UTF-1")
     .StartsWith("\xDD\x73\x66\x73", "UTF-EBCDIC")
     .StartsWith("\x0E\xFE\xFF", "SCSU")
     .StartsWith("\xFB\xEE\x28", "BOCU-1")
     .StartsWith("\x84\x31\x95\x33", "GB-18030")
     .Default(nullptr);
 
   if (InvalidBOM) {
     Diag.Report(Loc, diag::err_unsupported_bom)
       << InvalidBOM << ContentsEntry->getName();
-    Buffer.setInt(Buffer.getInt() | InvalidFlag);
+    IsBufferInvalid = true;
+    return None;
   }
 
-  if (Invalid)
-    *Invalid = isBufferInvalid();
-
-  return Buffer.getPointer();
+  return Buffer.getPointer()->getMemBufferRef();
 }
 
 unsigned LineTableInfo::getLineTableFilenameID(StringRef Name) {
   auto IterBool = FilenameIDs.try_emplace(Name, FilenamesByID.size());
   if (IterBool.second)
     FilenamesByID.push_back(&*IterBool.first);
   return IterBool.first->second;
 }
SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries,
   LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);
   SLocEntryLoaded.resize(LoadedSLocEntryTable.size());
   CurrentLoadedOffset -= TotalSize;
   int ID = LoadedSLocEntryTable.size();
   return std::make_pair(-ID - 1, CurrentLoadedOffset);
 }
 
 /// As part of recovering from missing or changed content, produce a
-/// fake, non-empty buffer.
-llvm::MemoryBuffer *SourceManager::getFakeBufferForRecovery() const {
-  if (!FakeBufferForRecovery)
-    FakeBufferForRecovery =
-        llvm::MemoryBuffer::getMemBuffer("<<<INVALID BUFFER>>");
-
-  return FakeBufferForRecovery.get();
-}
-
-/// As part of recovering from missing or changed content, produce a
 /// fake content cache.
 const SrcMgr::ContentCache *
 SourceManager::getFakeContentCacheForRecovery() const {
-  if (!FakeContentCacheForRecovery) {
+  if (!FakeContentCacheForRecovery)
     FakeContentCacheForRecovery = std::make_unique<SrcMgr::ContentCache>();
-    FakeContentCacheForRecovery->replaceBuffer(getFakeBufferForRecovery(),
-                                               /*DoNotFree=*/true);
-  }
   return FakeContentCacheForRecovery.get();
 }
 
 /// Returns the previous in-order FileID or an invalid FileID if there
 /// is no previous one.
 FileID SourceManager::getPreviousFileID(FileID FID) const {
   if (FID.isInvalid())
     return FileID();
SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
   assert(NextLocalOffset + TokLength + 1 > NextLocalOffset &&
          NextLocalOffset + TokLength + 1 <= CurrentLoadedOffset &&
          "Ran out of source locations!");
   // See createFileID for that +1.
   NextLocalOffset += TokLength + 1;
   return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));
 }
 
-const llvm::MemoryBuffer *
-SourceManager::getMemoryBufferForFile(const FileEntry *File, bool *Invalid) {
+llvm::Optional<llvm::MemoryBufferRef>
+SourceManager::getMemoryBufferForFile(const FileEntry *File) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
-  return IR->getBuffer(Diag, getFileManager(), SourceLocation(), Invalid);
+  return IR->getBuffer(Diag, getFileManager());
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          llvm::MemoryBuffer *Buffer,
                                          bool DoNotFree) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
 
SourceManager::bypassFileContentsOverride(const FileEntry &File) {
   return FE;
 }
 
 void SourceManager::setFileIsTransient(const FileEntry *File) {
   const SrcMgr::ContentCache *CC = getOrCreateContentCache(File);
   const_cast<SrcMgr::ContentCache *>(CC)->IsTransient = true;
 }
 
-StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
+llvm::Optional<StringRef> SourceManager::getBufferDataOrNone(FileID FID) const {
   bool MyInvalid = false;
   const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
-  if (!SLoc.isFile() || MyInvalid) {
-    if (Invalid)
-      *Invalid = true;
-    return "<<<<<INVALID SOURCE LOCATION>>>>>";
-  }
-
-  const llvm::MemoryBuffer *Buf = SLoc.getFile().getContentCache()->getBuffer(
-      Diag, getFileManager(), SourceLocation(), &MyInvalid);
-  if (Invalid)
-    *Invalid = MyInvalid;
-
-  if (MyInvalid)
-    return "<<<<<INVALID SOURCE LOCATION>>>>>";
+  if (!SLoc.isFile() || MyInvalid)
+    return None;
 
+  if (llvm::Optional<llvm::MemoryBufferRef> Buf =
+          SLoc.getFile().getContentCache()->getBuffer(Diag, getFileManager()))
     return Buf->getBuffer();
+  return None;
 }
 
 //===----------------------------------------------------------------------===//
 // SourceLocation manipulation methods.
 //===----------------------------------------------------------------------===//
 
 /// Return the FileID for a SourceLocation.
 ///
const char *SourceManager::getCharacterData(SourceLocation SL,
   bool CharDataInvalid = false;
   const SLocEntry &Entry = getSLocEntry(LocInfo.first, &CharDataInvalid);
   if (CharDataInvalid || !Entry.isFile()) {
     if (Invalid)
       *Invalid = true;
 
     return "<<<<INVALID BUFFER>>>>";
   }
-  const llvm::MemoryBuffer *Buffer =
-      Entry.getFile().getContentCache()->getBuffer(
-          Diag, getFileManager(), SourceLocation(), &CharDataInvalid);
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      Entry.getFile().getContentCache()->getBuffer(Diag, getFileManager());
   if (Invalid)
-    *Invalid = CharDataInvalid;
-  return Buffer->getBufferStart() + (CharDataInvalid? 0 : LocInfo.second);
+    *Invalid = !Buffer;
+  return Buffer ? Buffer->getBufferStart() + LocInfo.second : nullptr;
 }
 
 /// getColumnNumber - Return the column # for the specified file position.
 /// this is significantly cheaper to compute than the line number.
 unsigned SourceManager::getColumnNumber(FileID FID, unsigned FilePos,
                                         bool *Invalid) const {
-  bool MyInvalid = false;
-  const llvm::MemoryBuffer *MemBuf = getBuffer(FID, &MyInvalid);
+  llvm::Optional<llvm::MemoryBufferRef> MemBuf = getBuffer(FID);
   if (Invalid)
-    *Invalid = MyInvalid;
+    *Invalid = !MemBuf;
 
-  if (MyInvalid)
+  if (!MemBuf)
     return 1;
 
   // It is okay to request a position just past the end of the buffer.
   if (FilePos > MemBuf->getBufferSize()) {
     if (Invalid)
       *Invalid = true;
     return 1;
   }

 static LLVM_ATTRIBUTE_NOINLINE void
 ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI,
                    llvm::BumpPtrAllocator &Alloc,
                    const SourceManager &SM, bool &Invalid);
 static void ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI,
                                llvm::BumpPtrAllocator &Alloc,
                                const SourceManager &SM, bool &Invalid) {
   // Note that calling 'getBuffer()' may lazily page in the file.
-  const MemoryBuffer *Buffer =
-      FI->getBuffer(Diag, SM.getFileManager(), SourceLocation(), &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      FI->getBuffer(Diag, SM.getFileManager());
+  if (!Buffer)
     return;
 
   // Find the file offsets of all of the *physical* source lines.  This does
   // not look at trigraphs, escaped newlines, or anything else tricky.
   SmallVector<unsigned, 256> LineOffsets;
 
   // Line #1 starts at char 0.
   LineOffsets.push_back(0);

 
 /// Return the filename or buffer identifier of the buffer the location is in.
 /// Note that this name does not respect \#line directives.  Use getPresumedLoc
 /// for normal clients.
 StringRef SourceManager::getBufferName(SourceLocation Loc,
                                        bool *Invalid) const {
   if (isInvalid(Loc, Invalid)) return "<invalid loc>";
 
-  return getBuffer(getFileID(Loc), Invalid)->getBufferIdentifier();
+  if (auto Buffer = getBuffer(getFileID(Loc)))
+    return Buffer->getBufferIdentifier();
+  return "";
 }
 
 /// getPresumedLoc - This method returns the "presumed" location of a
 /// SourceLocation specifies.  A "presumed location" can be modified by \#line
 /// or GNU line marker directives.  This provides a view on the data that a
 /// user should see in diagnostics, for example.
 ///
 /// Note that a presumed location is always given as the expansion point of an
PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
 
   // To get the source name, first consult the FileEntry (if one exists)
   // before the MemBuffer as this will avoid unnecessarily paging in the
   // MemBuffer.
   FileID FID = LocInfo.first;
   StringRef Filename;
   if (C->OrigEntry)
     Filename = C->OrigEntry->getName();
-  else
-    Filename = C->getBuffer(Diag, getFileManager())->getBufferIdentifier();
+  else if (auto Name = C->getBufferIdentifier(Diag, getFileManager()))
+    Filename = *Name;
 
   unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
     return PresumedLoc();
   unsigned ColNo  = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
     return PresumedLoc();
 
SourceLocation SourceManager::translateLineCol(FileID FID,
   if (!Content->SourceLineCache) {
     bool MyInvalid = false;
     ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
     if (MyInvalid)
       return SourceLocation();
   }
 
   if (Line > Content->NumLines) {
-    unsigned Size = Content->getBuffer(Diag, getFileManager())->getBufferSize();
-    if (Size > 0)
-      --Size;
+    unsigned Size = 0;
+    if (llvm::Optional<unsigned> RawSize =
+            Content->getBufferSize(Diag, getFileManager()))
+      if (*RawSize > 0)
+        Size = *RawSize - 1;
     return FileLoc.getLocWithOffset(Size);
   }
 
-  const llvm::MemoryBuffer *Buffer = Content->getBuffer(Diag, getFileManager());
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      Content->getBuffer(Diag, getFileManager());
   unsigned FilePos = Content->SourceLineCache[Line - 1];
   const char *Buf = Buffer->getBufferStart() + FilePos;
   unsigned BufLength = Buffer->getBufferSize() - FilePos;
   if (BufLength == 0)
     return FileLoc.getLocWithOffset(FilePos);
 
   unsigned i = 0;
 
if (LOffs.first.isInvalid() || ROffs.first.isInvalid())
     return LOffs.first.isInvalid() && !ROffs.first.isInvalid();
 
   std::pair<bool, bool> InSameTU = isInTheSameTranslationUnit(LOffs, ROffs);
   if (InSameTU.first)
     return InSameTU.second;
 
   // If we arrived here, the location is either in a built-ins buffer or
   // associated with global inline asm. PR5662 and PR22576 are examples.
-
-  StringRef LB = getBuffer(LOffs.first)->getBufferIdentifier();
-  StringRef RB = getBuffer(ROffs.first)->getBufferIdentifier();
-  bool LIsBuiltins = LB == "<built-in>";
-  bool RIsBuiltins = RB == "<built-in>";
+  llvm::Optional<StringRef> LB = getBufferIdentifier(LOffs.first);
+  llvm::Optional<StringRef> RB = getBufferIdentifier(ROffs.first);
+  bool LIsBuiltins = LB == StringRef("<built-in>");
+  bool RIsBuiltins = RB == StringRef("<built-in>");
   // Sort built-in before non-built-in.
   if (LIsBuiltins || RIsBuiltins) {
     if (LIsBuiltins != RIsBuiltins)
       return LIsBuiltins;
     // Both are in built-in buffers, but from different files. We just claim that
     // lower IDs come first.
     return LOffs.first < ROffs.first;
   }
-  bool LIsAsm = LB == "<inline asm>";
-  bool RIsAsm = RB == "<inline asm>";
+  bool LIsAsm = LB == StringRef("<inline asm>");
+  bool RIsAsm = RB == StringRef("<inline asm>");
   // Sort assembler after built-ins, but before the rest.
   if (LIsAsm || RIsAsm) {
     if (LIsAsm != RIsAsm)
       return RIsAsm;
     assert(LOffs.first == ROffs.first);
     return false;
   }
-  bool LIsScratch = LB == "<scratch space>";
-  bool RIsScratch = RB == "<scratch space>";
+  bool LIsScratch = LB == StringRef("<scratch space>");
+  bool RIsScratch = RB == StringRef("<scratch space>");
   // Sort scratch after inline asm, but before the rest.
   if (LIsScratch || RIsScratch) {
     if (LIsScratch != RIsScratch)
       return LIsScratch;
     return LOffs.second < ROffs.second;
   }
   llvm_unreachable("Unsortable locations found");
 }

clang/lib/CodeGen/CGDebugInfo.cpp

 CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
   Checksum.clear();
 
   if (!CGM.getCodeGenOpts().EmitCodeView &&
       CGM.getCodeGenOpts().DwarfVersion < 5)
     return None;
 
   SourceManager &SM = CGM.getContext().getSourceManager();
-  bool Invalid;
-  const llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> MemBuffer = SM.getBuffer(FID);
+  if (!MemBuffer)
     return None;
 
   llvm::MD5 Hash;
   llvm::MD5::MD5Result Result;
 
   Hash.update(MemBuffer->getBuffer());
   Hash.final(Result);
 
   Hash.stringifyResult(Result, Checksum);
   return llvm::DIFile::CSK_MD5;
 }
 
 Optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM,
                                            FileID FID) {
   if (!CGM.getCodeGenOpts().EmbedSource)
     return None;
 
-  bool SourceInvalid = false;
-  StringRef Source = SM.getBufferData(FID, &SourceInvalid);
-
-  if (SourceInvalid)
-    return None;
-
-  return Source;
+  return SM.getBufferData(FID);
 }
 
 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
   if (!Loc.isValid())
     // If Location is not valid then use main input file.
     return TheCU->getFile();
 
   SourceManager &SM = CGM.getContext().getSourceManager();

clang/lib/CodeGen/CodeGenAction.cpp

void CodeGenAction::ExecuteAction() {
   if (getCurrentFileKind().getLanguage() == Language::LLVM_IR) {
     BackendAction BA = static_cast<BackendAction>(Act);
     CompilerInstance &CI = getCompilerInstance();
     std::unique_ptr<raw_pwrite_stream> OS =
         GetOutputStream(CI, getCurrentFile(), BA);
     if (BA != Backend_EmitNothing && !OS)
       return;
 
-    bool Invalid;
     SourceManager &SM = CI.getSourceManager();
     FileID FID = SM.getMainFileID();
-    const llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
-    if (Invalid)
+    llvm::Optional<llvm::MemoryBufferRef> MainFile = SM.getBuffer(FID);
+    if (!MainFile)
       return;
 
     TheModule = loadModule(*MainFile);
     if (!TheModule)
       return;
 
     const TargetOptions &TargetOpts = CI.getTargetOpts();
     if (TheModule->getTargetTriple() != TargetOpts.Triple) {
       CI.getDiagnostics().Report(SourceLocation(),
                                  diag::warn_fe_override_module)
           << TargetOpts.Triple;
       TheModule->setTargetTriple(TargetOpts.Triple);
     }
 
-    EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(),
-                 MainFile->getMemBufferRef());
+    EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(), *MainFile);
 
     LLVMContext &Ctx = TheModule->getContext();
     Ctx.setInlineAsmDiagnosticHandler(BitcodeInlineAsmDiagHandler,
                                       &CI.getDiagnostics());
 
     EmitBackendOutput(CI.getDiagnostics(), CI.getHeaderSearchOpts(),
                       CI.getCodeGenOpts(), TargetOpts, CI.getLangOpts(),
                       CI.getTarget().getDataLayout(), TheModule.get(), BA,

clang/lib/Format/FormatTokenLexer.cpp

FormatTokenLexer::FormatTokenLexer(const SourceManager &SourceMgr, FileID ID,
                                    unsigned Column, const FormatStyle &Style,
                                    encoding::Encoding Encoding)
     : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
       Column(Column), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID),
       Style(Style), IdentTable(getFormattingLangOpts(Style)),
       Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
-  Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
+  Lex.reset(new Lexer(ID, SourceMgr.getBufferOrFake(ID), SourceMgr,
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
   for (const std::string &ForEachMacro : Style.ForEachMacros)
     Macros.insert({&IdentTable.get(ForEachMacro), TT_ForEachMacro});
   for (const std::string &StatementMacro : Style.StatementMacros)
     Macros.insert({&IdentTable.get(StatementMacro), TT_StatementMacro});
   for (const std::string &TypenameMacro : Style.TypenameMacros)
bool FormatTokenLexer::tryMergeConflictMarkers() {
   // into a single token with a special token type that the unwrapped line
   // parser will use to correctly rebuild the underlying code.
 
   FileID ID;
   // Get the position of the first token in the line.
   unsigned FirstInLineOffset;
   std::tie(ID, FirstInLineOffset) = SourceMgr.getDecomposedLoc(
       Tokens[FirstInLineIndex]->getStartOfNonWhitespace());
-  StringRef Buffer = SourceMgr.getBuffer(ID)->getBuffer();
+  StringRef Buffer = SourceMgr.getBufferOrFake(ID).getBuffer();
   // Calculate the offset of the start of the current line.
   auto LineOffset = Buffer.rfind('\n', FirstInLineOffset);
   if (LineOffset == StringRef::npos) {
     LineOffset = 0;
   } else {
     ++LineOffset;
   }
 

clang/lib/Frontend/ASTUnit.cpp

 }
 
 StringRef ASTUnit::getMainFileName() const {
   if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
     const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0];
     if (Input.isFile())
       return Input.getFile();
     else
-      return Input.getBuffer()->getBufferIdentifier();
+      return Input.getBuffer().getBufferIdentifier();
   }
 
   if (SourceMgr) {
     if (const FileEntry *
           FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID()))
       return FE->getName();
   }
 

clang/lib/Frontend/CompilerInstance.cpp

bool CompilerInstance::InitializeSourceManager(
     DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
   SrcMgr::CharacteristicKind Kind =
       Input.getKind().getFormat() == InputKind::ModuleMap
           ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
                              : SrcMgr::C_User_ModuleMap
           : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
 
   if (Input.isBuffer()) {
-    SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
-                                                   Input.getBuffer(), Kind));
+    SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind));
     assert(SourceMgr.getMainFileID().isValid() &&
            "Couldn't establish MainFileID!");
     return true;
   }
 
   StringRef InputFile = Input.getFile();
 
   // Figure out where to get and map in the main file.

clang/lib/Frontend/FrontendAction.cpp

 ///        directive. (We need to do this because the directive will not be
 ///        visited by the preprocessor.)
 static SourceLocation ReadOriginalFileName(CompilerInstance &CI,
                                            std::string &InputFile,
                                            bool IsModuleMap = false) {
   auto &SourceMgr = CI.getSourceManager();
   auto MainFileID = SourceMgr.getMainFileID();
 
-  bool Invalid = false;
-  const auto *MainFileBuf = SourceMgr.getBuffer(MainFileID, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> MainFileBuf =
+      SourceMgr.getBuffer(MainFileID);
+  if (!MainFileBuf)
     return SourceLocation();
 
   std::unique_ptr<Lexer> RawLexer(
-      new Lexer(MainFileID, MainFileBuf, SourceMgr, CI.getLangOpts()));
+      new Lexer(MainFileID, *MainFileBuf, SourceMgr, CI.getLangOpts()));
 
   // If the first line has the syntax of
   //
   // # NUM "FILENAME"
   //
   // we use FILENAME as the input file name.
   Token T;
   if (RawLexer->LexFromRawLexer(T) || T.getKind() != tok::hash)
if (EndOfLineMarker.isValid())
       Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second;
   }
 
   // Load the module map file.
   if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset,
                            PresumedModuleMapFile))
     return true;
 
-  if (SrcMgr.getBuffer(ModuleMapID)->getBufferSize() == Offset)
+  if (SrcMgr.getBufferOrFake(ModuleMapID).getBufferSize() == Offset)
     Offset = 0;
 
   return false;
 }
 
 static Module *prepareToBuildModule(CompilerInstance &CI,
                                     StringRef ModuleMapFilename) {
   if (CI.getLangOpts().CurrentModule.empty()) {
if (Kind.getFormat() == InputKind::ModuleMap) {
       assert(ASTModule && "module file does not define its own module");
       Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
     } else {
       auto &OldSM = AST->getSourceManager();
       FileID ID = OldSM.getMainFileID();
       if (auto *File = OldSM.getFileEntryForID(ID))
         Input = FrontendInputFile(File->getName(), Kind);
       else
-        Input = FrontendInputFile(OldSM.getBuffer(ID), Kind);
+        Input = FrontendInputFile(OldSM.getBufferOrFake(ID), Kind);
     }
     setCurrentInput(Input, std::move(AST));
   }
 
   // AST files follow a very different path, since they share objects via the
   // AST unit.
   if (Input.getKind().getFormat() == InputKind::Precompiled) {
     assert(!usesPreprocessorOnly() && "this case was handled above");

clang/lib/Frontend/FrontendActions.cpp

bool GenerateHeaderModuleAction::PrepareToExecuteAction(
   // Convert the header file inputs into a single module input buffer.
   SmallString<256> HeaderContents;
   ModuleHeaders.reserve(Inputs.size());
   for (const FrontendInputFile &FIF : Inputs) {
     // FIXME: We should support re-compiling from an AST file.
     if (FIF.getKind().getFormat() != InputKind::Source || !FIF.isFile()) {
       CI.getDiagnostics().Report(diag::err_module_header_file_not_found)
           << (FIF.isFile() ? FIF.getFile()
-                           : FIF.getBuffer()->getBufferIdentifier());
+                           : FIF.getBuffer().getBufferIdentifier());
       return true;
     }
 
     HeaderContents += "#include \"";
     HeaderContents += FIF.getFile();
     HeaderContents += "\"\n";
     ModuleHeaders.push_back(FIF.getFile());
   }
   Buffer = llvm::MemoryBuffer::getMemBufferCopy(
       HeaderContents, Module::getModuleInputBufferName());
 
   // Set that buffer up as our "real" input.
   Inputs.clear();
-  Inputs.push_back(FrontendInputFile(Buffer.get(), Kind, /*IsSystem*/false));
+  Inputs.push_back(
+      FrontendInputFile(Buffer->getMemBufferRef(), Kind, /*IsSystem*/ false));
 
   return GenerateModuleAction::PrepareToExecuteAction(CI);
 }
 
 bool GenerateHeaderModuleAction::BeginSourceFileAction(
     CompilerInstance &CI) {
   CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderModule);
 

 // Preprocessor Actions
 //===----------------------------------------------------------------------===//
 
 void DumpRawTokensAction::ExecuteAction() {
   Preprocessor &PP = getCompilerInstance().getPreprocessor();
   SourceManager &SM = PP.getSourceManager();
 
   // Start lexing the specified input file.
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
-  Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
+  Lexer RawLex(SM.getMainFileID(), SM.getBufferOrFake(SM.getMainFileID()), SM,
+               PP.getLangOpts());
   RawLex.SetKeepWhitespaceMode(true);
 
   Token RawTok;
   RawLex.LexFromRawLexer(RawTok);
   while (RawTok.isNot(tok::eof)) {
     PP.DumpToken(RawTok, true);
     llvm::errs() << "\n";
     RawLex.LexFromRawLexer(RawTok);
void PrintPreprocessedAction::ExecuteAction() {
   // In this fashion, the output format should match the input format, unless
   // the input format has inconsistent line endings.
   //
   // This should be a relatively fast operation since most files won't have
   // all of their source code on a single line. However, that is still a
   // concern, so if we scan for too long, we'll just assume the file should
   // be opened in binary mode.
   bool BinaryMode = true;
-  bool InvalidFile = false;
   const SourceManager& SM = CI.getSourceManager();
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
-                                                     &InvalidFile);
-  if (!InvalidFile) {
+  if (llvm::Optional<llvm::MemoryBufferRef> Buffer =
+          SM.getBuffer(SM.getMainFileID())) {
     const char *cur = Buffer->getBufferStart();
     const char *end = Buffer->getBufferEnd();
     const char *next = (cur != end) ? cur + 1 : end;
 
     // Limit ourselves to only scanning 256 characters into the source
     // file.  This is mostly a sanity check in case the file has no
     // newlines whatsoever.
     if (end - cur > 256) end = cur + 256;
#undef EXTENSION
   OS << "\n]\n";
 
   OS << "}";
 }
 
 void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
   SourceManager &SM = CI.getPreprocessor().getSourceManager();
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
 
   llvm::SmallString<1024> Output;
   llvm::SmallVector<minimize_source_to_dependency_directives::Token, 32> Toks;
   if (minimizeSourceToDependencyDirectives(
-          FromFile->getBuffer(), Output, Toks, &CI.getDiagnostics(),
+          FromFile.getBuffer(), Output, Toks, &CI.getDiagnostics(),
           SM.getLocForStartOfFile(SM.getMainFileID()))) {
     assert(CI.getDiagnostics().hasErrorOccurred() &&
            "no errors reported for failure");
 
     // Preprocess the source when verifying the diagnostics to capture the
     // 'expected' comments.
     if (CI.getDiagnosticOpts().VerifyDiagnostics) {
       // Make sure we don't emit new diagnostics!

clang/lib/Frontend/PrecompiledPreamble.cpp

if (!FileOrErr ||
         *FileOrErr == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))
       continue;
     auto File = *FileOrErr;
     if (time_t ModTime = File->getModificationTime()) {
       FilesInPreamble[File->getName()] =
           PrecompiledPreamble::PreambleFileHash::createForFile(File->getSize(),
                                                                ModTime);
     } else {
-      const llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File);
+      llvm::Optional<llvm::MemoryBufferRef> Buffer =
+          SourceMgr.getMemoryBufferForFile(File);
       FilesInPreamble[File->getName()] =
           PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(Buffer);
     }
   }
 
   return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes),
                              PreambleEndsAtStartOfLine,
                              std::move(FilesInPreamble));
for (const auto &R : PreprocessorOpts.RemappedFiles) {
     OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile(
         Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime()));
   }
 
   // OverridenFileBuffers tracks only the files not found in VFS.
   llvm::StringMap<PreambleFileHash> OverridenFileBuffers;
   for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
     const PrecompiledPreamble::PreambleFileHash PreambleHash =
-        PreambleFileHash::createForMemoryBuffer(RB.second);
+        PreambleFileHash::createForMemoryBuffer(
+            RB.second ? RB.second->getMemBufferRef()
+                      : llvm::Optional<llvm::MemoryBufferRef>(None));
     llvm::vfs::Status Status;
     if (moveOnNoError(VFS->status(RB.first), Status))
       OverriddenFiles[Status.getUniqueID()] = PreambleHash;
     else
       OverridenFileBuffers[RB.first] = PreambleHash;
   }
 
   // Check whether anything has changed.
PrecompiledPreamble::PreambleFileHash::createForFile(off_t Size,
   Result.Size = Size;
   Result.ModTime = ModTime;
   Result.MD5 = {};
   return Result;
 }
 
 PrecompiledPreamble::PreambleFileHash
 PrecompiledPreamble::PreambleFileHash::createForMemoryBuffer(
-    const llvm::MemoryBuffer *Buffer) {
+    llvm::Optional<llvm::MemoryBufferRef> Buffer) {
   PreambleFileHash Result;
-  Result.Size = Buffer->getBufferSize();
+  Result.Size = Buffer ? Buffer->getBufferSize() : 0;
   Result.ModTime = 0;
 
   llvm::MD5 MD5Ctx;
-  MD5Ctx.update(Buffer->getBuffer().data());
+  MD5Ctx.update(Buffer ? Buffer->getBuffer().data() : nullptr);
   MD5Ctx.final(Result.MD5);
 
   return Result;
 }
 
 void PrecompiledPreamble::configurePreamble(
     PreambleBounds Bounds, CompilerInvocation &CI,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> &VFS,

clang/lib/Frontend/Rewrite/HTMLPrint.cpp

void HTMLPrinter::HandleTranslationUnit(ASTContext &Ctx) {
   const FileEntry* Entry = R.getSourceMgr().getFileEntryForID(FID);
   StringRef Name;
   // In some cases, in particular the case where the input is from stdin,
   // there is no entry.  Fall back to the memory buffer for a name in those
   // cases.
   if (Entry)
     Name = Entry->getName();
   else
-    Name = R.getSourceMgr().getBuffer(FID)->getBufferIdentifier();
+    Name = R.getSourceMgr().getBufferOrFake(FID).getBufferIdentifier();
 
   html::AddLineNumbers(R, FID);
   html::AddHeaderFooterInternalBuiltinCSS(R, FID, Name);
 
   // If we have a preprocessor, relex the file and syntax highlight.
   // We might not have a preprocessor if we come from a deserialized AST file,
   // for example.
 

clang/lib/Frontend/Rewrite/InclusionRewriter.cpp

struct IncludedFile {
     IncludedFile(FileID Id, SrcMgr::CharacteristicKind FileType,
                  const DirectoryLookup *DirLookup)
         : Id(Id), FileType(FileType), DirLookup(DirLookup) {}
   };
   Preprocessor &PP; ///< Used to find inclusion directives.
   SourceManager &SM; ///< Used to read and manage source files.
   raw_ostream &OS; ///< The destination stream for rewritten contents.
   StringRef MainEOL; ///< The line ending marker to use.
-  const llvm::MemoryBuffer *PredefinesBuffer; ///< The preprocessor predefines.
+  Optional<MemoryBufferRef> PredefinesBuffer; ///< The preprocessor predefines.
   bool ShowLineMarkers; ///< Show #line markers.
   bool UseLineDirectives; ///< Use of line directives or line markers.
   /// Tracks where inclusions that change the file are found.
   std::map<unsigned, IncludedFile> FileIncludes;
   /// Tracks where inclusions that import modules are found.
   std::map<unsigned, const Module *> ModuleIncludes;
   /// Tracks where inclusions that enter modules (in a module build) are found.
   std::map<unsigned, const Module *> ModuleEntryIncludes;
   /// Used transitively for building up the FileIncludes mapping over the
   /// various \c PPCallbacks callbacks.
   SourceLocation LastInclusionLocation;
 public:
   InclusionRewriter(Preprocessor &PP, raw_ostream &OS, bool ShowLineMarkers,
                     bool UseLineDirectives);
   void Process(FileID FileId, SrcMgr::CharacteristicKind FileType,
                const DirectoryLookup *DirLookup);
-  void setPredefinesBuffer(const llvm::MemoryBuffer *Buf) {
+  void setPredefinesBuffer(Optional<MemoryBufferRef> Buf) {
     PredefinesBuffer = Buf;
   }
   void detectMainFileEOL();
   void handleModuleBegin(Token &Tok) {
     assert(Tok.getKind() == tok::annot_module_begin);
     ModuleEntryIncludes.insert({Tok.getLocation().getRawEncoding(),
                                 (Module *)Tok.getAnnotationValue()});
   }
 private:
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
                           const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
   void WriteLineInfo(StringRef Filename, int Line,
                      SrcMgr::CharacteristicKind FileType,
                      StringRef Extra = StringRef());
   void WriteImplicitModuleImport(const Module *Mod);
-  void OutputContentUpTo(const MemoryBuffer &FromFile,
-                         unsigned &WriteFrom, unsigned WriteTo,
-                         StringRef EOL, int &lines,
+  void OutputContentUpTo(MemoryBufferRef FromFile, unsigned &WriteFrom,
+                         unsigned WriteTo, StringRef EOL, int &lines,
                          bool EnsureNewline);
   void CommentOutDirective(Lexer &DirectivesLex, const Token &StartToken,
-                           const MemoryBuffer &FromFile, StringRef EOL,
+                           MemoryBufferRef FromFile, StringRef EOL,
                            unsigned &NextToWrite, int &Lines);
   bool HandleHasInclude(FileID FileId, Lexer &RawLex,
                         const DirectoryLookup *Lookup, Token &Tok,
                         bool &FileExists);
   const IncludedFile *FindIncludeAtLocation(SourceLocation Loc) const;
   const Module *FindModuleAtLocation(SourceLocation Loc) const;
   const Module *FindEnteredModule(SourceLocation Loc) const;
   StringRef NextIdentifierName(Lexer &RawLex, Token &RawToken);
 };
 
 }  // end anonymous namespace
 
 /// Initializes an InclusionRewriter with a \p PP source and \p OS destination.
 InclusionRewriter::InclusionRewriter(Preprocessor &PP, raw_ostream &OS,
                                      bool ShowLineMarkers,
                                      bool UseLineDirectives)
     : PP(PP), SM(PP.getSourceManager()), OS(OS), MainEOL("\n"),
-      PredefinesBuffer(nullptr), ShowLineMarkers(ShowLineMarkers),
-      UseLineDirectives(UseLineDirectives),
+      ShowLineMarkers(ShowLineMarkers), UseLineDirectives(UseLineDirectives),
       LastInclusionLocation(SourceLocation()) {}
 
 /// Write appropriate line information as either #line directives or GNU line
 /// markers depending on what mode we're in, including the \p Filename and
 /// \p Line we are located at, using the specified \p EOL line separator, and
 /// any \p Extra context specifiers in GNU line directives.
 void InclusionRewriter::WriteLineInfo(StringRef Filename, int Line,
                                       SrcMgr::CharacteristicKind FileType,
InclusionRewriter::FindEnteredModule(SourceLocation Loc) const {
   const auto I = ModuleEntryIncludes.find(Loc.getRawEncoding());
   if (I != ModuleEntryIncludes.end())
     return I->second;
   return nullptr;
 }
 
 /// Detect the likely line ending style of \p FromFile by examining the first
 /// newline found within it.
-static StringRef DetectEOL(const MemoryBuffer &FromFile) {
+static StringRef DetectEOL(MemoryBufferRef FromFile) {
   // Detect what line endings the file uses, so that added content does not mix
   // the style. We need to check for "\r\n" first because "\n\r" will match
   // "\r\n\r\n".
   const char *Pos = strchr(FromFile.getBufferStart(), '\n');
   if (!Pos)
     return "\n";
   if (Pos - 1 >= FromFile.getBufferStart() && Pos[-1] == '\r')
     return "\r\n";
   if (Pos + 1 < FromFile.getBufferEnd() && Pos[1] == '\r')
     return "\n\r";
   return "\n";
 }
 
 void InclusionRewriter::detectMainFileEOL() {
-  bool Invalid;
-  const MemoryBuffer &FromFile = *SM.getBuffer(SM.getMainFileID(), &Invalid);
-  assert(!Invalid);
-  if (Invalid)
+  Optional<MemoryBufferRef> FromFile = SM.getBuffer(SM.getMainFileID());
+  if (!FromFile)
     return; // Should never happen, but whatever.
-  MainEOL = DetectEOL(FromFile);
+  MainEOL = DetectEOL(*FromFile);
 }
 
 /// Writes out bytes from \p FromFile, starting at \p NextToWrite and ending at
 /// \p WriteTo - 1.
-void InclusionRewriter::OutputContentUpTo(const MemoryBuffer &FromFile,
+void InclusionRewriter::OutputContentUpTo(MemoryBufferRef FromFile,
                                           unsigned &WriteFrom, unsigned WriteTo,
                                           StringRef LocalEOL, int &Line,
                                           bool EnsureNewline) {
   if (WriteTo <= WriteFrom)
     return;
-  if (&FromFile == PredefinesBuffer) {
+  if (FromFile == PredefinesBuffer) {
     // Ignore the #defines of the predefines buffer.
     WriteFrom = WriteTo;
     return;
   }
 
   // If we would output half of a line ending, advance one character to output
   // the whole line ending.  All buffers are null terminated, so looking ahead
   // one byte is safe.

 
 /// Print characters from \p FromFile starting at \p NextToWrite up until the
 /// inclusion directive at \p StartToken, then print out the inclusion
 /// inclusion directive disabled by a #if directive, updating \p NextToWrite
 /// and \p Line to track the number of source lines visited and the progress
 /// through the \p FromFile buffer.
 void InclusionRewriter::CommentOutDirective(Lexer &DirectiveLex,
                                             const Token &StartToken,
-                                            const MemoryBuffer &FromFile,
+                                            MemoryBufferRef FromFile,
                                             StringRef LocalEOL,
                                             unsigned &NextToWrite, int &Line) {
   OutputContentUpTo(FromFile, NextToWrite,
                     SM.getFileOffset(StartToken.getLocation()), LocalEOL, Line,
                     false);
   Token DirectiveToken;
   do {
     DirectiveLex.LexFromRawLexer(DirectiveToken);
   } while (!DirectiveToken.is(tok::eod) && DirectiveToken.isNot(tok::eof));
-  if (&FromFile == PredefinesBuffer) {
+  if (FromFile == PredefinesBuffer) {
     // OutputContentUpTo() would not output anything anyway.
     return;
   }
   OS << "#if 0 /* expanded by -frewrite-includes */" << MainEOL;
   OutputContentUpTo(FromFile, NextToWrite,
                     SM.getFileOffset(DirectiveToken.getLocation()) +
                         DirectiveToken.getLength(),
                     LocalEOL, Line, true);
bool InclusionRewriter::HandleHasInclude(
   return true;
 }
 
 /// Use a raw lexer to analyze \p FileId, incrementally copying parts of it
 /// and including content of included files recursively.
 void InclusionRewriter::Process(FileID FileId,
                                 SrcMgr::CharacteristicKind FileType,
                                 const DirectoryLookup *DirLookup) {
-  bool Invalid;
-  const MemoryBuffer &FromFile = *SM.getBuffer(FileId, &Invalid);
-  assert(!Invalid && "Attempting to process invalid inclusion");
+  Optional<MemoryBufferRef> MaybeFromFile = SM.getBuffer(FileId);
+  assert(MaybeFromFile && "Attempting to process invalid inclusion");
+  auto FromFile = *MaybeFromFile;
   StringRef FileName = FromFile.getBufferIdentifier();
-  Lexer RawLex(FileId, &FromFile, PP.getSourceManager(), PP.getLangOpts());
+  Lexer RawLex(FileId, FromFile, PP.getSourceManager(), PP.getLangOpts());
   RawLex.SetCommentRetentionState(false);
 
   StringRef LocalEOL = DetectEOL(FromFile);
 
   // Per the GNU docs: "1" indicates entering a new file.
   if (FileId == SM.getMainFileID() || FileId == PP.getPredefinesFileID())
     WriteLineInfo(FileName, 1, FileType, "");
   else

clang/lib/Frontend/Rewrite/RewriteMacros.cpp

 /// LexRawTokensFromMainFile - Lets all the raw tokens from the main file into
 /// the specified vector.
 static void LexRawTokensFromMainFile(Preprocessor &PP,
                                      std::vector<Token> &RawTokens) {
   SourceManager &SM = PP.getSourceManager();
 
   // Create a lexer to lex all the tokens of the main file in raw mode.  Even
   // though it is in raw mode, it will not return comments.
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
   Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
 
   // Switch on comment lexing because we really do want them.
   RawLex.SetCommentRetentionState(true);
 
   Token RawTok;
   do {
     RawLex.LexFromRawLexer(RawTok);

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

void RewriteModernObjC::InitializeCommon(ASTContext &context) {
   NumObjCStringLiterals = 0;
   PropParentMap = nullptr;
   CurrentBody = nullptr;
   DisableReplaceStmt = false;
   objc_impl_method = false;
 
   // Get the ID and start/end of the main file.
   MainFileID = SM->getMainFileID();
-  const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID);
-  MainFileStart = MainBuf->getBufferStart();
-  MainFileEnd = MainBuf->getBufferEnd();
+  llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID);
+  MainFileStart = MainBuf.getBufferStart();
+  MainFileEnd = MainBuf.getBufferEnd();
 
   Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());
 }
 
 //===----------------------------------------------------------------------===//
 // Top Level Driver Code
 //===----------------------------------------------------------------------===//
 

clang/lib/Frontend/Rewrite/RewriteObjC.cpp

void RewriteObjC::InitializeCommon(ASTContext &context) {
   NumObjCStringLiterals = 0;
   PropParentMap = nullptr;
   CurrentBody = nullptr;
   DisableReplaceStmt = false;
   objc_impl_method = false;
 
   // Get the ID and start/end of the main file.
   MainFileID = SM->getMainFileID();
-  const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID);
-  MainFileStart = MainBuf->getBufferStart();
-  MainFileEnd = MainBuf->getBufferEnd();
+  llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID);
+  MainFileStart = MainBuf.getBufferStart();
+  MainFileEnd = MainBuf.getBufferEnd();
 
   Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());
 }
 
 //===----------------------------------------------------------------------===//
 // Top Level Driver Code
 //===----------------------------------------------------------------------===//
 

clang/lib/Frontend/VerifyDiagnosticConsumer.cpp

 /// \return true if any directives were found.
 static bool findDirectives(SourceManager &SM, FileID FID,
                            const LangOptions &LangOpts) {
   // Create a raw lexer to pull all the comments out of FID.
   if (FID.isInvalid())
     return false;
 
   // Create a lexer to lex all the tokens of the main file in raw mode.
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
   Lexer RawLex(FID, FromFile, SM, LangOpts);
 
   // Return comments as tokens, this is how we find expected diagnostics.
   RawLex.SetCommentRetentionState(true);
 
   Token Tok;
   Tok.setKind(tok::comment);
   VerifyDiagnosticConsumer::DirectiveStatus Status =

clang/lib/Lex/Lexer.cpp

void Lexer::InitLexer(const char *BufStart, const char *BufPtr,
   // Default to not keeping comments.
   ExtendedTokenMode = 0;
 }
 
 /// Lexer constructor - Create a new lexer object for the specified buffer
 /// with the specified preprocessor managing the lexing process.  This lexer
 /// assumes that the associated file buffer and Preprocessor objects will
 /// outlive it, so it doesn't take ownership of either of them.
-Lexer::Lexer(FileID FID, const llvm::MemoryBuffer *InputFile, Preprocessor &PP)
+Lexer::Lexer(FileID FID, const llvm::MemoryBufferRef &InputFile,
+             Preprocessor &PP)
     : PreprocessorLexer(&PP, FID),
       FileLoc(PP.getSourceManager().getLocForStartOfFile(FID)),
       LangOpts(PP.getLangOpts()) {
-  InitLexer(InputFile->getBufferStart(), InputFile->getBufferStart(),
-            InputFile->getBufferEnd());
+  InitLexer(InputFile.getBufferStart(), InputFile.getBufferStart(),
+            InputFile.getBufferEnd());
 
   resetExtendedTokenMode();
 }
 
 /// Lexer constructor - Create a new raw lexer object.  This object is only
 /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the text
 /// range will outlive it, so it doesn't take ownership of it.
 Lexer::Lexer(SourceLocation fileloc, const LangOptions &langOpts,
              const char *BufStart, const char *BufPtr, const char *BufEnd)
     : FileLoc(fileloc), LangOpts(langOpts) {
   InitLexer(BufStart, BufPtr, BufEnd);
 
   // We *are* in raw mode.
   LexingRawMode = true;
 }
 
 /// Lexer constructor - Create a new raw lexer object.  This object is only
 /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the text
 /// range will outlive it, so it doesn't take ownership of it.
-Lexer::Lexer(FileID FID, const llvm::MemoryBuffer *FromFile,
+Lexer::Lexer(FileID FID, const llvm::MemoryBufferRef &FromFile,
              const SourceManager &SM, const LangOptions &langOpts)
-    : Lexer(SM.getLocForStartOfFile(FID), langOpts, FromFile->getBufferStart(),
-            FromFile->getBufferStart(), FromFile->getBufferEnd()) {}
+    : Lexer(SM.getLocForStartOfFile(FID), langOpts, FromFile.getBufferStart(),
+            FromFile.getBufferStart(), FromFile.getBufferEnd()) {}
 
 void Lexer::resetExtendedTokenMode() {
   assert(PP && "Cannot reset token mode without a preprocessor");
   if (LangOpts.TraditionalCPP)
     SetKeepWhitespaceMode(true);
   else
     SetCommentRetentionState(PP->getCommentRetentionState());
 }

 Lexer *Lexer::Create_PragmaLexer(SourceLocation SpellingLoc,
                                  SourceLocation ExpansionLocStart,
                                  SourceLocation ExpansionLocEnd,
                                  unsigned TokLen, Preprocessor &PP) {
   SourceManager &SM = PP.getSourceManager();
 
   // Create the lexer as if we were going to lex the file normally.
   FileID SpellingFID = SM.getFileID(SpellingLoc);
-  const llvm::MemoryBuffer *InputFile = SM.getBuffer(SpellingFID);
+  llvm::MemoryBufferRef InputFile = SM.getBufferOrFake(SpellingFID);
   Lexer *L = new Lexer(SpellingFID, InputFile, PP);
 
   // Now that the lexer is created, change the start/end locations so that we
   // just lex the subsection of the file that we want.  This is lexing from a
   // scratch buffer.
   const char *StrData = SM.getCharacterData(SpellingLoc);
 
   L->BufferPtr = StrData;

clang/lib/Lex/ModuleMap.cpp

bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
   // If the module map file wasn't already entered, do so now.
   if (ID.isInvalid()) {
     auto FileCharacter =
         IsSystem ? SrcMgr::C_System_ModuleMap : SrcMgr::C_User_ModuleMap;
     ID = SourceMgr.createFileID(File, ExternModuleLoc, FileCharacter);
   }
 
   assert(Target && "Missing target information");
-  const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(ID);
+  llvm::Optional<llvm::MemoryBufferRef> Buffer = SourceMgr.getBuffer(ID);
   if (!Buffer)
     return ParsedModuleMap[File] = true;
   assert((!Offset || *Offset <= Buffer->getBufferSize()) &&
          "invalid buffer offset");
 
   // Parse this module map file.
   Lexer L(SourceMgr.getLocForStartOfFile(ID), MMapLangOpts,
           Buffer->getBufferStart(),

clang/lib/Lex/PPLexerChange.cpp

bool Preprocessor::EnterSourceFile(FileID FID, const DirectoryLookup *CurDir,
                                    SourceLocation Loc) {
   assert(!CurTokenLexer && "Cannot #include a file inside a macro!");
   ++NumEnteredSourceFiles;
 
   if (MaxIncludeStackDepth < IncludeMacroStack.size())
     MaxIncludeStackDepth = IncludeMacroStack.size();
 
   // Get the MemoryBuffer for this FID, if it fails, we fail.
-  bool Invalid = false;
-  const llvm::MemoryBuffer *InputFile =
-    getSourceManager().getBuffer(FID, Loc, &Invalid);
-  if (Invalid) {
+  llvm::Optional<llvm::MemoryBufferRef> InputFile =
+      getSourceManager().getBuffer(FID, Loc);
+  if (!InputFile) {
     SourceLocation FileStart = SourceMgr.getLocForStartOfFile(FID);
     Diag(Loc, diag::err_pp_error_opening_file)
       << std::string(SourceMgr.getBufferName(FileStart)) << "";
     return true;
   }
 
   if (isCodeCompletionEnabled() &&
       SourceMgr.getFileEntryForID(FID) == CodeCompletionFile) {
     CodeCompletionFileLoc = SourceMgr.getLocForStartOfFile(FID);
     CodeCompletionLoc =
         CodeCompletionFileLoc.getLocWithOffset(CodeCompletionOffset);
   }
 
-  EnterSourceFileWithLexer(new Lexer(FID, InputFile, *this), CurDir);
+  EnterSourceFileWithLexer(new Lexer(FID, *InputFile, *this), CurDir);
   return false;
 }
 
 /// EnterSourceFileWithLexer - Add a source file to the top of the include stack
 ///  and start lexing tokens from it instead of the current buffer.
 void Preprocessor::EnterSourceFileWithLexer(Lexer *TheLexer,
                                             const DirectoryLookup *CurDir) {
 

clang/lib/Lex/Preprocessor.cpp

bool Preprocessor::SetCodeCompletionPoint(const FileEntry *File,
                                           unsigned CompleteColumn) {
   assert(File);
   assert(CompleteLine && CompleteColumn && "Starts from 1:1");
   assert(!CodeCompletionFile && "Already set");
 
   using llvm::MemoryBuffer;
 
   // Load the actual file's contents.
-  bool Invalid = false;
-  const MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      SourceMgr.getMemoryBufferForFile(File);
+  if (!Buffer)
     return true;
 
   // Find the byte position of the truncation point.
   const char *Position = Buffer->getBufferStart();
   for (unsigned Line = 1; Line < CompleteLine; ++Line) {
     for (; *Position; ++Position) {
       if (*Position != '\r' && *Position != '\n')
         continue;

clang/lib/Rewrite/HTMLRewrite.cpp

default:
       break;
     }
   }
 }
 
 void html::EscapeText(Rewriter &R, FileID FID,
                       bool EscapeSpaces, bool ReplaceTabs) {
 
-  const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
-  const char* C = Buf->getBufferStart();
-  const char* FileEnd = Buf->getBufferEnd();
+  llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID);
+  const char *C = Buf.getBufferStart();
+  const char *FileEnd = Buf.getBufferEnd();
 
   assert (C <= FileEnd);
 
   RewriteBuffer &RB = R.getEditBuffer(FID);
 
   unsigned ColNo = 0;
   for (unsigned FilePos = 0; C != FileEnd ; ++C, ++FilePos) {
     switch (*C) {
static void AddLineNumber(RewriteBuffer &RB, unsigned LineNo,
   } else {
     RB.InsertTextBefore(B, OS.str());
     RB.InsertTextBefore(E, "</td></tr>");
   }
 }
 
 void html::AddLineNumbers(Rewriter& R, FileID FID) {
 
-  const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
-  const char* FileBeg = Buf->getBufferStart();
-  const char* FileEnd = Buf->getBufferEnd();
+  llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID);
+  const char *FileBeg = Buf.getBufferStart();
+  const char *FileEnd = Buf.getBufferEnd();
   const char* C = FileBeg;
   RewriteBuffer &RB = R.getEditBuffer(FID);
 
   assert (C <= FileEnd);
 
   unsigned LineNo = 0;
   unsigned FilePos = 0;
 
void html::AddLineNumbers(Rewriter& R, FileID FID) {
   os << "<table class=\"code\" data-fileid=\"" << FID.getHashValue() << "\">\n";
   RB.InsertTextBefore(0, os.str());
   RB.InsertTextAfter(FileEnd - FileBeg, "</table>");
 }
 
 void html::AddHeaderFooterInternalBuiltinCSS(Rewriter &R, FileID FID,
                                              StringRef title) {
 
-  const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
-  const char* FileStart = Buf->getBufferStart();
-  const char* FileEnd = Buf->getBufferEnd();
+  llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID);
+  const char *FileStart = Buf.getBufferStart();
+  const char *FileEnd = Buf.getBufferEnd();
 
   SourceLocation StartLoc = R.getSourceMgr().getLocForStartOfFile(FID);
   SourceLocation EndLoc = StartLoc.getLocWithOffset(FileEnd-FileStart);
 
   std::string s;
   llvm::raw_string_ostream os(s);
   os << "<!doctype html>\n" // Use HTML 5 doctype
         "<html>\n<head>\n";

 /// SyntaxHighlight - Relex the specified FileID and annotate the HTML with
 /// information about keywords, macro expansions etc.  This uses the macro
 /// table state from the end of the file, so it won't be perfectly perfect,
 /// but it will be reasonably close.
 void html::SyntaxHighlight(Rewriter &R, FileID FID, const Preprocessor &PP) {
   RewriteBuffer &RB = R.getEditBuffer(FID);
 
   const SourceManager &SM = PP.getSourceManager();
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
   Lexer L(FID, FromFile, SM, PP.getLangOpts());
   const char *BufferStart = L.getBuffer().data();
 
   // Inform the preprocessor that we want to retain comments as tokens, so we
   // can highlight them.
   L.SetCommentRetentionState(true);
 
   // Lex all the tokens in raw mode, to avoid entering #includes or expanding

 /// file, to re-expand macros and insert (into the HTML) information about the
 /// macro expansions.  This won't be perfectly perfect, but it will be
 /// reasonably close.
 void html::HighlightMacros(Rewriter &R, FileID FID, const Preprocessor& PP) {
   // Re-lex the raw token stream into a token buffer.
   const SourceManager &SM = PP.getSourceManager();
   std::vector<Token> TokenStream;
 
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
   Lexer L(FID, FromFile, SM, PP.getLangOpts());
 
   // Lex all the tokens in raw mode, to avoid entering #includes or expanding
   // macros.
   while (1) {
     Token Tok;
     L.LexFromRawLexer(Tok);
 

clang/lib/Rewrite/TokenRewriter.cpp

 
 using namespace clang;
 
 TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM,
                              const LangOptions &LangOpts) {
   ScratchBuf.reset(new ScratchBuffer(SM));
 
   // Create a lexer to lex all the tokens of the main file in raw mode.
-  const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
+  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
   Lexer RawLex(FID, FromFile, SM, LangOpts);
 
   // Return all comments and whitespace as tokens.
   RawLex.SetKeepWhitespaceMode(true);
 
   // Lex the file, populating our datastructures.
   Token RawTok;
   RawLex.LexFromRawLexer(RawTok);

clang/lib/Serialization/ASTWriter.cpp

if (SLoc->isFile()) {
           EmitBlob = true;
       } else {
         // The source location entry is a buffer. The blob associated
         // with this entry contains the contents of the buffer.
 
         // We add one to the size so that we capture the trailing NULL
         // that is required by llvm::MemoryBuffer::getMemBuffer (on
         // the reader side).
-        const llvm::MemoryBuffer *Buffer =
+        llvm::Optional<llvm::MemoryBufferRef> Buffer =
             Content->getBuffer(PP.getDiagnostics(), PP.getFileManager());
-        StringRef Name = Buffer->getBufferIdentifier();
+        StringRef Name = Buffer ? Buffer->getBufferIdentifier() : "";
         Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
                                   StringRef(Name.data(), Name.size() + 1));
         EmitBlob = true;
 
         if (Name == "<built-in>")
           PreloadSLocs.push_back(SLocEntryOffsets.size());
       }
 
       if (EmitBlob) {
         // Include the implicit terminating null character in the on-disk buffer
         // if we're writing it uncompressed.
-        const llvm::MemoryBuffer *Buffer =
+        llvm::Optional<llvm::MemoryBufferRef> Buffer =
             Content->getBuffer(PP.getDiagnostics(), PP.getFileManager());
+        if (!Buffer)
+          Buffer = llvm::MemoryBufferRef("<<<INVALID BUFFER>>>", "");
         StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
         emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
                  SLocBufferBlobAbbrv);
       }
     } else {
       // The source location entry is a macro expansion.
       const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
       AddSourceLocation(Expansion.getSpellingLoc(), Record);

clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr(
   // If NSLocalizedString macro is wrapped in another macro, we need to
   // unwrap the expansion until we get to the NSLocalizedStringMacro.
   while (SE.isExpansion()) {
     SL = SE.getExpansion().getSpellingLoc();
     SLInfo = Mgr.getSourceManager().getDecomposedLoc(SL);
     SE = Mgr.getSourceManager().getSLocEntry(SLInfo.first);
   }
 
-  bool Invalid = false;
-  const llvm::MemoryBuffer *BF =
-      Mgr.getSourceManager().getBuffer(SLInfo.first, SL, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> BF =
+      Mgr.getSourceManager().getBuffer(SLInfo.first, SL);
+  if (!BF)
     return;
 
   Lexer TheLexer(SL, LangOptions(), BF->getBufferStart(),
                  BF->getBufferStart() + SLInfo.second, BF->getBufferEnd());
 
   Token I;
   Token Result;    // This will hold the token just before the last ')'
   int p_count = 0; // This is for parenthesis matching

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
                                               SourceRange Range) {
   SourceRange ExpansionRange(SM.getExpansionLoc(Range.getBegin()),
                              SM.getExpansionRange(Range.getEnd()).getEnd());
 
   FileID FID = SM.getFileID(ExpansionRange.getBegin());
   if (FID != SM.getFileID(ExpansionRange.getEnd()))
     return None;
 
-  bool Invalid;
-  const llvm::MemoryBuffer *Buffer = SM.getBuffer(FID, &Invalid);
-  if (Invalid)
+  llvm::Optional<llvm::MemoryBufferRef> Buffer = SM.getBuffer(FID);
+  if (!Buffer)
     return None;
 
   unsigned BeginOffset = SM.getFileOffset(ExpansionRange.getBegin());
   unsigned EndOffset = SM.getFileOffset(ExpansionRange.getEnd());
   StringRef Snippet = Buffer->getBuffer().slice(BeginOffset, EndOffset);
 
   // We're searching the raw bytes of the buffer here, which might include
   // escaped newlines and such. That's okay; we're trying to decide whether the

clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
 
   SourceManager &SM = R.getSourceMgr();
   assert(&Pos.getManager() == &SM && "SourceManagers are different!");
   std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);
 
   if (LPosInfo.first != BugFileID)
     return;
 
-  const llvm::MemoryBuffer *Buf = SM.getBuffer(LPosInfo.first);
-  const char* FileStart = Buf->getBufferStart();
+  llvm::MemoryBufferRef Buf = SM.getBufferOrFake(LPosInfo.first);
+  const char *FileStart = Buf.getBufferStart();
 
   // Compute the column number.  Rewind from the current position to the start
   // of the line.
   unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
   const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
   const char *LineStart = TokInstantiationPtr-ColNo;
 
   // Compute LineEnd.
   const char *LineEnd = TokInstantiationPtr;
-  const char* FileEnd = Buf->getBufferEnd();
+  const char *FileEnd = Buf.getBufferEnd();
   while (*LineEnd != '\n' && LineEnd != FileEnd)
     ++LineEnd;
 
   // Compute the margin offset by counting tabs and non-tabs.
   unsigned PosNo = 0;
   for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
     PosNo += *c == '\t' ? 8 : 1;
 

clang/lib/StaticAnalyzer/Core/IssueHash.cpp

if (const auto *ND = dyn_cast<NamedDecl>(D)) {
     }
 
     return DeclName;
   }
 
   return "";
 }
 
-static StringRef GetNthLineOfFile(const llvm::MemoryBuffer *Buffer, int Line) {
+static StringRef GetNthLineOfFile(llvm::Optional<llvm::MemoryBufferRef> Buffer,
+                                  int Line) {
   if (!Buffer)
     return "";
 
   llvm::line_iterator LI(*Buffer, false);
   for (; !LI.is_at_eof() && LI.line_number() != Line; ++LI)
     ;
 
   return *LI;
 }
 
 static std::string NormalizeLine(const SourceManager &SM, FullSourceLoc &L,
                                  const LangOptions &LangOpts) {
   static StringRef Whitespaces = " \t\n";
 
-  StringRef Str = GetNthLineOfFile(SM.getBuffer(L.getFileID(), L),
+  StringRef Str = GetNthLineOfFile(SM.getBufferOrFake(L.getFileID(), L),
                                    L.getExpansionLineNumber());
   StringRef::size_type col = Str.find_first_not_of(Whitespaces);
   if (col == StringRef::npos)
     col = 1; // The line only contains whitespace.
   else
     col++;
   SourceLocation StartOfLine =
       SM.translateLineCol(SM.getFileID(L), L.getExpansionLineNumber(), col);
-  const llvm::MemoryBuffer *Buffer =
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
       SM.getBuffer(SM.getFileID(StartOfLine), StartOfLine);
   if (!Buffer)
     return {};
 
   const char *BufferPos = SM.getCharacterData(StartOfLine);
 
   Token Token;
   Lexer Lexer(SM.getLocForStartOfFile(SM.getFileID(StartOfLine)), LangOpts,

clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

static MacroNameAndArgs getMacroNameAndArgs(SourceLocation ExpanLoc,
                                             const Preprocessor &PP) {
 
   const SourceManager &SM = PP.getSourceManager();
   const LangOptions &LangOpts = PP.getLangOpts();
 
   // First, we create a Lexer to lex *at the expansion location* the tokens
   // referring to the macro's name and its arguments.
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(ExpanLoc);
-  const llvm::MemoryBuffer *MB = SM.getBuffer(LocInfo.first);
-  const char *MacroNameTokenPos = MB->getBufferStart() + LocInfo.second;
+  llvm::MemoryBufferRef MB = SM.getBufferOrFake(LocInfo.first);
+  const char *MacroNameTokenPos = MB.getBufferStart() + LocInfo.second;
 
   Lexer RawLexer(SM.getLocForStartOfFile(LocInfo.first), LangOpts,
-                 MB->getBufferStart(), MacroNameTokenPos, MB->getBufferEnd());
+                 MB.getBufferStart(), MacroNameTokenPos, MB.getBufferEnd());
 
   // Acquire the macro's name.
   Token TheTok;
   RawLexer.LexFromRawLexer(TheTok);
 
   std::string MacroName = PP.getSpelling(TheTok);
 
   const auto *II = PP.getIdentifierInfo(MacroName);

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

for (const Decl *Callee : VisitedCallees)
                                                  : Callee->getCanonicalDecl());
     VisitedAsTopLevel.insert(D);
   }
 }
 
 static bool isBisonFile(ASTContext &C) {
   const SourceManager &SM = C.getSourceManager();
   FileID FID = SM.getMainFileID();
-  StringRef Buffer = SM.getBuffer(FID)->getBuffer();
+  StringRef Buffer = SM.getBufferOrFake(FID).getBuffer();
   if (Buffer.startswith("/* A Bison parser, made by"))
     return true;
   return false;
 }
 
 void AnalysisConsumer::runAnalysisOnTranslationUnit(ASTContext &C) {
   BugReporter BR(*Mgr);
   TranslationUnitDecl *TU = C.getTranslationUnitDecl();

clang/lib/Tooling/Inclusions/HeaderIncludes.cpp

 // \p GetOffsetAfterSequence should be a function that matches a sequence of
 // tokens and returns an offset after the sequence.
 unsigned getOffsetAfterTokenSequence(
     StringRef FileName, StringRef Code, const IncludeStyle &Style,
     llvm::function_ref<unsigned(const SourceManager &, Lexer &, Token &)>
         GetOffsetAfterSequence) {
   SourceManagerForFile VirtualSM(FileName, Code);
   SourceManager &SM = VirtualSM.get();
-  Lexer Lex(SM.getMainFileID(), SM.getBuffer(SM.getMainFileID()), SM,
+  Lexer Lex(SM.getMainFileID(), SM.getBufferOrFake(SM.getMainFileID()), SM,
             createLangOpts());
   Token Tok;
   // Get the first token.
   Lex.LexFromRawLexer(Tok);
   return GetOffsetAfterSequence(SM, Lex, Tok);
 }
 
 // Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,

clang/lib/Tooling/Syntax/Tokens.cpp

if (T.getKind() == tok::raw_identifier && !T.needsCleaning() &&
         !T.hasUCN()) { // FIXME: support needsCleaning and hasUCN cases.
       clang::IdentifierInfo &II = Identifiers.get(T.getRawIdentifier());
       T.setIdentifierInfo(&II);
       T.setKind(II.getTokenID());
     }
     Tokens.push_back(syntax::Token(T));
   };
 
-  Lexer L(FID, SM.getBuffer(FID), SM, LO);
+  Lexer L(FID, SM.getBufferOrFake(FID), SM, LO);
 
   clang::Token T;
   while (!L.LexFromRawLexer(T))
     AddToken(T);
   // 'eof' is only the last token if the input is null-terminated. Never store
   // it, for consistency.
   if (T.getKind() != tok::eof)
     AddToken(T);

clang/tools/clang-diff/ClangDiff.cpp

if (IsLeft) {
     MyTag = 'R';
     OtherTag = 'L';
     LeftId = TargetId;
     RightId = Id;
   }
   unsigned Begin, End;
   std::tie(Begin, End) = Tree.getSourceRangeOffsets(Node);
   const SourceManager &SrcMgr = Tree.getASTContext().getSourceManager();
-  auto Code = SrcMgr.getBuffer(SrcMgr.getMainFileID())->getBuffer();
+  auto Code = SrcMgr.getBufferOrFake(SrcMgr.getMainFileID()).getBuffer();
   for (; Offset < Begin; ++Offset)
     printHtml(OS, Code[Offset]);
   OS << "<span id='" << MyTag << Id << "' "
      << "tid='" << OtherTag << TargetId << "' ";
   OS << "title='";
   printHtml(OS, Node.getTypeLabel());
   OS << "\n" << LeftId << " -> " << RightId;
   std::string Value = Tree.getNodeValue(Node);

clang/tools/clang-import-test/clang-import-test.cpp

 
 private:
   static void PrintSourceForLocation(const SourceLocation &Loc,
                                      SourceManager &SM) {
     const char *LocData = SM.getCharacterData(Loc, /*Invalid=*/nullptr);
     unsigned LocColumn =
         SM.getSpellingColumnNumber(Loc, /*Invalid=*/nullptr) - 1;
     FileID FID = SM.getFileID(Loc);
-    const llvm::MemoryBuffer *Buffer =
-        SM.getBuffer(FID, Loc, /*Invalid=*/nullptr);
+    llvm::MemoryBufferRef Buffer = SM.getBufferOrFake(FID, Loc);
 
-    assert(LocData >= Buffer->getBufferStart() &&
-           LocData < Buffer->getBufferEnd());
+    assert(LocData >= Buffer.getBufferStart() &&
+           LocData < Buffer.getBufferEnd());
 
     const char *LineBegin = LocData - LocColumn;
 
-    assert(LineBegin >= Buffer->getBufferStart());
+    assert(LineBegin >= Buffer.getBufferStart());
 
     const char *LineEnd = nullptr;
 
     for (LineEnd = LineBegin; *LineEnd != '\n' && *LineEnd != '\r' &&
-                              LineEnd < Buffer->getBufferEnd();
+                              LineEnd < Buffer.getBufferEnd();
          ++LineEnd)
       ;
 
     llvm::StringRef LineString(LineBegin, LineEnd - LineBegin);
 
     llvm::errs() << LineString << '\n';
     llvm::errs().indent(LocColumn);
     llvm::errs() << '^';

clang/tools/libclang/CIndex.cpp

const char *clang_getFileContents(CXTranslationUnit TU, CXFile file,
                                   size_t *size) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
 
   const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager();
   FileID fid = SM.translateFile(static_cast<FileEntry *>(file));
-  bool Invalid = true;
-  const llvm::MemoryBuffer *buf = SM.getBuffer(fid, &Invalid);
-  if (Invalid) {
+  llvm::Optional<llvm::MemoryBufferRef> buf = SM.getBuffer(fid);
+  if (!buf) {
     if (size)
       *size = 0;
     return nullptr;
   }
   if (size)
     *size = buf->getBufferSize();
   return buf->getBufferStart();
 }

llvm/include/llvm/Support/LineIterator.h

 //===- LineIterator.h - Iterator to read a text buffer's lines --*- 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_LINEITERATOR_H
 #define LLVM_SUPPORT_LINEITERATOR_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include <iterator>
 
 namespace llvm {
 
 class MemoryBuffer;
+class MemoryBufferRef;
 
 /// A forward iterator which reads text lines from a buffer.
 ///
 /// This class provides a forward iterator interface for reading one line at
 /// a time from a buffer. When default constructed the iterator will be the
 /// "end" iterator.
 ///
 /// The iterator is aware of what line number it is currently processing. It
 /// strips blank lines by default, and comment lines given a comment-starting
 /// character.
 ///
 /// Note that this iterator requires the buffer to be nul terminated.
 class line_iterator
     : public std::iterator<std::forward_iterator_tag, StringRef> {
-  const MemoryBuffer *Buffer;
+  Optional<StringRef> Buffer;
   char CommentMarker;
   bool SkipBlanks;
 
   unsigned LineNumber;
   StringRef CurrentLine;
 
+  explicit line_iterator(StringRef Buffer, bool SkipBlanks, char CommentMarker);
+
 public:
   /// Default construct an "end" iterator.
-  line_iterator() : Buffer(nullptr) {}
+  line_iterator() = default;
+
+  /// Construct a new iterator around an unowned memory buffer.
+  explicit line_iterator(const MemoryBufferRef &Buffer, bool SkipBlanks = true,
+                         char CommentMarker = '\0');
 
   /// Construct a new iterator around some memory buffer.
   explicit line_iterator(const MemoryBuffer &Buffer, bool SkipBlanks = true,
                          char CommentMarker = '\0');
 
   /// Return true if we've reached EOF or are an "end" iterator.
   bool is_at_eof() const { return !Buffer; }
 
line_iterator operator++(int) {
     return tmp;
   }
 
   /// Get the current line as a \c StringRef.
   StringRef operator*() const { return CurrentLine; }
   const StringRef *operator->() const { return &CurrentLine; }
 
   friend bool operator==(const line_iterator &LHS, const line_iterator &RHS) {
-    return LHS.Buffer == RHS.Buffer &&
-           LHS.CurrentLine.begin() == RHS.CurrentLine.begin();
+    if (LHS.Buffer && RHS.Buffer) {
+      // Use pointer identity to compare Buffer.
+      if (LHS.Buffer->begin() != RHS.Buffer->begin())
+        return false;
+    } else if (LHS.Buffer || RHS.Buffer) {
+      return false;
+    }
+    return LHS.CurrentLine.begin() == RHS.CurrentLine.begin();
   }
 
   friend bool operator!=(const line_iterator &LHS, const line_iterator &RHS) {
     return !(LHS == RHS);
   }
 
 private:
   /// Advance the iterator to the next line.
   void advance();
 };
 }
 
 #endif

llvm/include/llvm/Support/MemoryBuffer.h

public:
 
   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(); }
+
+  /// Check if two memory buffer refs have the same pointer identity.
+  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();
+  }
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef)
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_MEMORYBUFFER_H

llvm/lib/Support/LineIterator.cpp

static bool skipIfAtLineEnd(const char *&P) {
   }
   if (*P == '\r' && *(P + 1) == '\n') {
     P += 2;
     return true;
   }
   return false;
 }
 
+line_iterator::line_iterator(const MemoryBufferRef &Buffer, bool SkipBlanks,
+                             char CommentMarker)
+    : line_iterator(StringRef(Buffer.getBufferStart(), Buffer.getBufferSize()),
+                    SkipBlanks, CommentMarker) {}
+
 line_iterator::line_iterator(const MemoryBuffer &Buffer, bool SkipBlanks,
                              char CommentMarker)
-    : Buffer(Buffer.getBufferSize() ? &Buffer : nullptr),
+    : line_iterator(StringRef(Buffer.getBufferStart(), Buffer.getBufferSize()),
+                    SkipBlanks, CommentMarker) {}
+
+line_iterator::line_iterator(StringRef Buffer, bool SkipBlanks,
+                             char CommentMarker)
+    : Buffer(Buffer.empty() ? Optional<StringRef>(None) : Buffer),
       CommentMarker(CommentMarker), SkipBlanks(SkipBlanks), LineNumber(1),
-      CurrentLine(Buffer.getBufferSize() ? Buffer.getBufferStart() : nullptr,
-                  0) {
+      CurrentLine(Buffer.empty() ? nullptr : Buffer.begin(), 0) {
   // Ensure that if we are constructed on a non-empty memory buffer that it is
   // a null terminated buffer.
-  if (Buffer.getBufferSize()) {
-    assert(Buffer.getBufferEnd()[0] == '\0');
-    // Make sure we don't skip a leading newline if we're keeping blanks
-    if (SkipBlanks || !isAtLineEnd(Buffer.getBufferStart()))
-      advance();
-  }
-}
+  if (Buffer.empty())
+    return;
+
+  assert(Buffer.end()[0] == '\0');
+  if (SkipBlanks || !isAtLineEnd(Buffer.begin()))
 
 void line_iterator::advance() {
   assert(Buffer && "Cannot advance past the end!");
 
   const char *Pos = CurrentLine.end();
-  assert(Pos == Buffer->getBufferStart() || isAtLineEnd(Pos) || *Pos == '\0');
+  assert(Pos == Buffer->begin() || isAtLineEnd(Pos) || *Pos == '\0');
 
   if (skipIfAtLineEnd(Pos))
     ++LineNumber;
   if (!SkipBlanks && isAtLineEnd(Pos)) {
     // Nothing to do for a blank line.
   } else if (CommentMarker == '\0') {
     // If we're not stripping comments, this is simpler.
     while (skipIfAtLineEnd(Pos))
for (;;) {
       if (!skipIfAtLineEnd(Pos))
         break;
       ++LineNumber;
     }
   }
 
   if (*Pos == '\0') {
     // We've hit the end of the buffer, reset ourselves to the end state.
-    Buffer = nullptr;
+    Buffer = None;
     CurrentLine = StringRef();
     return;
   }
 
   // Measure the line.
   size_t Length = 0;
   while (Pos[Length] != '\0' && !isAtLineEnd(&Pos[Length])) {
     ++Length;
   }
 
   CurrentLine = StringRef(Pos, Length);
 }