clang/Basic: Replace ContentCache::getBuffer with Optional semantics

[dexonsmith]

Summary

Remove ContentCache::getBuffer, which always returned a
dereferenceable MemoryBuffer* and had a bool*Invalid out parameter,
and replace it with:

• ContentCache::getBufferOrNone, which returns Optional<MemoryBufferRef>. This is the new API that consumers should use. Later it could be renamed to getBuffer, but intentionally using a different name to root out any unexpected callers.
• ContentCache::getBufferPointer, which returns MemoryBuffer* with "optional" semantics. This is private to avoid growing callers and SourceManager has temporarily been made a friend to access it. Later paches will update the transitive callers to not need a raw pointer, and eventually this will be deleted.

No functionality change intended here.

[dexonsmith]

Note that this is split off from https://reviews.llvm.org/D66782.

[dexonsmith]

Fixed a bug where Invalid was only set when it was true.

[dexonsmith]

Fix a few more places where Invalid needs to be set to false.

[dexonsmith]

Cleaned up the (fixed) Invalid logic to reduce the size of the diff and use a consistent pattern. Thanks for you patience with the false start; I think this is ready now.

[dexonsmith]

Hah, and now I notice while working on a follow-up that SourceManager::getBufferOrNone was missing a const-qualifier (the use in this patch didn't need it). Fixed that too.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

if (BracketEndIndex != StringRef::npos) {
       }
     }
   }
   return true;
 }
 
 static llvm::Optional<StringRef> getBuffer(const SourceManager &SM, FileID File,
                                            bool AllowIO) {
-  // This is similar to the implementation of SourceManager::getBufferData(),
-  // but uses ContentCache::getRawBuffer() rather than getBuffer() if
-  // AllowIO=false, to avoid triggering file I/O if the file contents aren't
-  // already mapped.
-  bool CharDataInvalid = false;
-  const SrcMgr::SLocEntry &Entry = SM.getSLocEntry(File, &CharDataInvalid);
-  if (CharDataInvalid || !Entry.isFile())
-    return llvm::None;
-  const SrcMgr::ContentCache *Cache = Entry.getFile().getContentCache();
-  const llvm::MemoryBuffer *Buffer =
-      AllowIO ? Cache->getBuffer(SM.getDiagnostics(), SM.getFileManager(),
-                                 SourceLocation(), &CharDataInvalid)
-              : Cache->getRawBuffer();
-  if (!Buffer || CharDataInvalid)
-    return llvm::None;
-  return Buffer->getBuffer();
+  return AllowIO ? SM.getBufferDataOrNone(File)
+                 : SM.getBufferDataIfLoaded(File);
 }
 
 static bool LineIsMarkedWithNOLINT(const SourceManager &SM, SourceLocation Loc,
                                    unsigned DiagID,
                                    const ClangTidyContext &Context,
                                    bool AllowIO) {
   FileID File;
   unsigned Offset;

clang/include/clang/Basic/SourceManager.h

public:
 
     /// 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.
+    llvm::Optional<llvm::MemoryBufferRef>
+    getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM,
+                    SourceLocation Loc = SourceLocation()) const;
+
+  private:
+    /// Returns pointer to memory buffer.
     ///
-    /// \param Invalid If non-NULL, will be set \c true if an error occurred.
-    const llvm::MemoryBuffer *getBuffer(DiagnosticsEngine &Diag,
+    /// TODO: SourceManager needs access to this for now, but once that's done
+    /// we should remove this API.
+    const llvm::MemoryBuffer *getBufferPointer(DiagnosticsEngine &Diag,
                                                FileManager &FM,
-                                        SourceLocation Loc = SourceLocation(),
-                                        bool *Invalid = nullptr) const;
+                                               SourceLocation Loc) const;
+    friend class clang::SourceManager;
 
+  public:
     /// 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;
 
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.
+  llvm::Optional<llvm::MemoryBufferRef>
+  getBufferOrNone(FileID FID, SourceLocation Loc = SourceLocation()) {
+    bool MyInvalid = false;
+    const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
+    if (MyInvalid || !Entry.isFile())
+      return None;
+
+    return Entry.getFile().getContentCache()->getBufferOrNone(
+        Diag, getFileManager(), Loc);
+  }
+
+  /// 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.
+  ///
+  /// TODO: Update users of Invalid to call getBufferOrNone and change return
+  /// type to MemoryBufferRef.
   const llvm::MemoryBuffer *getBuffer(FileID FID, SourceLocation Loc,
                                       bool *Invalid = nullptr) const {
     bool MyInvalid = false;
     const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
     if (MyInvalid || !Entry.isFile()) {
       if (Invalid)
         *Invalid = true;
 
       return getFakeBufferForRecovery();
     }
 
-    return Entry.getFile().getContentCache()->getBuffer(Diag, getFileManager(),
-                                                        Loc, Invalid);
+    auto *B = Entry.getFile().getContentCache()->getBufferPointer(
+        Diag, getFileManager(), Loc);
+    if (Invalid)
+      *Invalid = B ? false : true;
+    return B ? B : getFakeBufferForRecovery();
   }
 
   const llvm::MemoryBuffer *getBuffer(FileID FID,
                                       bool *Invalid = nullptr) const {
     return getBuffer(FID, SourceLocation(), Invalid);
   }
 
   /// Returns the FileEntry record for the provided FileID.
public:
 
   /// 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;
 
+  /// Return a StringRef to the source buffer data for the
+  /// specified FileID, returning None if 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, returning None if it's not yet loaded.
+  ///
+  /// \param FID The file ID whose contents will be returned.
+  llvm::Optional<StringRef> getBufferDataIfLoaded(FileID FID) const;
+
   /// 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;
 

clang/lib/AST/ASTImporter.cpp

if (!IsBuiltin && !Cache->BufferOverridden) {
         if (Entry)
           ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
                                    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)
-        // FIXME: Use a new error kind?
+      llvm::Optional<llvm::MemoryBufferRef> FromBuf =
+          Cache->getBufferOrNone(FromContext.getDiagnostics(),
+                                 FromSM.getFileManager(), SourceLocation{});
+      if (!FromBuf)
         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/SourceManager.cpp

const char *InvalidBOM =
           .StartsWith("\x0E\xFE\xFF", "SCSU")
           .StartsWith("\xFB\xEE\x28", "BOCU-1")
           .StartsWith("\x84\x31\x95\x33", "GB-18030")
           .Default(nullptr);
 
   return InvalidBOM;
 }
 
-const llvm::MemoryBuffer *ContentCache::getBuffer(DiagnosticsEngine &Diag,
-                                                  FileManager &FM,
-                                                  SourceLocation Loc,
-                                                  bool *Invalid) const {
+llvm::Optional<llvm::MemoryBufferRef>
+ContentCache::getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM,
+                              SourceLocation Loc) const {
+  if (auto *B = getBufferPointer(Diag, FM, Loc))
+    return B->getMemBufferRef();
+  return None;
+}
+
+const llvm::MemoryBuffer *
+ContentCache::getBufferPointer(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 nullptr;
+  if (auto *B = Buffer.getPointer())
+    return B;
+  if (!ContentsEntry)
+    return nullptr;
 
   // 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();
+    return nullptr;
   }
 
   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();
+    return nullptr;
   }
 
   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();
+    return nullptr;
   }
 
   // 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 = getInvalidBOM(BufStr);
 
   if (InvalidBOM) {
     Diag.Report(Loc, diag::err_unsupported_bom)
       << InvalidBOM << ContentsEntry->getName();
     Buffer.setInt(Buffer.getInt() | InvalidFlag);
+    return nullptr;
   }
 
-  if (Invalid)
-    *Invalid = isBufferInvalid();
-
   return Buffer.getPointer();
 }
 
 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::createExpansionLocImpl(const ExpansionInfo &Info,
   NextLocalOffset += TokLength + 1;
   return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));
 }
 
 const llvm::MemoryBuffer *
 SourceManager::getMemoryBufferForFile(const FileEntry *File, bool *Invalid) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
-  return IR->getBuffer(Diag, getFileManager(), SourceLocation(), Invalid);
+  if (auto *B = IR->getBufferPointer(Diag, getFileManager(), SourceLocation())) {
+    if (Invalid)
+      *Invalid = false;
+    return B;
+  }
+  if (Invalid)
+    *Invalid = true;
+  return getFakeBufferForRecovery();
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          llvm::MemoryBuffer *Buffer,
                                          bool DoNotFree) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
 
Optional<FileEntryRef> SourceManager::getFileEntryRefForID(FileID FID) const {
 
   const SrcMgr::ContentCache *Content = Entry.getFile().getContentCache();
   if (!Content || !Content->OrigEntry)
     return None;
   return FileEntryRef(Entry.getFile().getName(), *Content->OrigEntry);
 }
 
 StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
-  bool MyInvalid = false;
-  const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
-  if (!SLoc.isFile() || MyInvalid) {
-    if (Invalid)
-      *Invalid = true;
-    return "<<<<<INVALID SOURCE LOCATION>>>>>";
-  }
+  if (auto B = getBufferDataOrNone(FID))
+    return *B;
 
-  const llvm::MemoryBuffer *Buf = SLoc.getFile().getContentCache()->getBuffer(
-      Diag, getFileManager(), SourceLocation(), &MyInvalid);
-  if (Invalid)
-    *Invalid = MyInvalid;
-
-  if (MyInvalid)
-    return "<<<<<INVALID SOURCE LOCATION>>>>>";
+llvm::Optional<StringRef>
+SourceManager::getBufferDataIfLoaded(FileID FID) const {
+  bool MyInvalid = false;
+  const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
+  if (!SLoc.isFile() || MyInvalid)
+    return None;
 
+  if (const llvm::MemoryBuffer *Buf =
+          SLoc.getFile().getContentCache()->getRawBuffer())
     return Buf->getBuffer();
+  return None;
+}
+
+llvm::Optional<StringRef> SourceManager::getBufferDataOrNone(FileID FID) const {
+  bool MyInvalid = false;
+  const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
+  if (!SLoc.isFile() || MyInvalid)
+    return None;
+
+  if (auto B = SLoc.getFile().getContentCache()->getBufferOrNone(
+          Diag, getFileManager(), SourceLocation()))
+    return B->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);
+  if (llvm::Optional<llvm::MemoryBufferRef> Buffer =
+          Entry.getFile().getContentCache()->getBufferOrNone(
+              Diag, getFileManager(), SourceLocation()))
+    return Buffer->getBufferStart() + LocInfo.second;
+
   if (Invalid)
-    *Invalid = CharDataInvalid;
-  return Buffer->getBufferStart() + (CharDataInvalid? 0 : LocInfo.second);
+    *Invalid = true;
+  return "<<<<INVALID BUFFER>>>>";
 }
 
 /// 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);

 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->getBufferOrNone(Diag, SM.getFileManager(), SourceLocation());
+  if (!Buffer) {
+    Invalid = true;
     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);
 
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 Buffer = C->getBufferOrNone(Diag, getFileManager()))
+    Filename = Buffer->getBufferIdentifier();
 
   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,
   // SourceLineCache for it on demand.
   if (!Content->SourceLineCache) {
     bool MyInvalid = false;
     ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
     if (MyInvalid)
       return SourceLocation();
   }
 
+  llvm::Optional<llvm::MemoryBufferRef> Buffer =
+      Content->getBufferOrNone(Diag, getFileManager());
+  if (!Buffer)
+    return SourceLocation();
+
   if (Line > Content->NumLines) {
-    unsigned Size = Content->getBuffer(Diag, getFileManager())->getBufferSize();
+    unsigned Size = Buffer->getBufferSize();
     if (Size > 0)
       --Size;
     return FileLoc.getLocWithOffset(Size);
   }
 
-  const llvm::MemoryBuffer *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;
 

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 =
-            Content->getBuffer(PP.getDiagnostics(), PP.getFileManager());
-        StringRef Name = Buffer->getBufferIdentifier();
+        llvm::Optional<llvm::MemoryBufferRef> Buffer =
+            Content->getBufferOrNone(PP.getDiagnostics(), PP.getFileManager());
+        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 =
-            Content->getBuffer(PP.getDiagnostics(), PP.getFileManager());
+        llvm::Optional<llvm::MemoryBufferRef> Buffer =
+            Content->getBufferOrNone(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);