[clang] Store filename per include instead of mutating filename

[benlangmuir]

Summary

Depends on https://reviews.llvm.org/D137303

This change is not ready to land, but I wanted to put it up for early review in case the approach looks wrong to anyone. I'm also curious if there are any related cases this does not handle. I verified it fixes the /showIncludes and preprocessor examples mentioned in the comments on https://reviews.llvm.org/D135220 and https://github.com/llvm/llvm-project/issues/58726.

---

When including a header, store the filename per include (per FileInfo)
rather than storing it once in the ContentCache and mutating it. This
fixes the spelling of includes for -E and --show-includes when working
with symlinks/hardlinks for headers included multiple times.

Logically, the filename and FileEntryRef belong to the FileInfo, but to
avoid increasing the size of SLocEntry we indirect them in a new struct
NamedContentCache.

TODO

• Evaluate the performance cost of indirecting ContentCache an extra level.
• Audit uses of FileInfos to see if we need to do extra for for NamedFileInfos.
• Consider making the FileEntryRef changes here the default -- it doesn't make sense to me that FileEntryRef == or DenseMap would match FileEntry pointer semantics instead of filename semantics.

[dexonsmith]

Consider making the FileEntryRef changes here the default -- it doesn't make sense to me that FileEntryRef == or DenseMap would match FileEntry pointer semantics instead of filename semantics.

Yeah, that was something I added, and I agree it's unfortunate / hard to reason about. It was a concession to make it easier to replace FileEntry* with FileEntryRef seamlessly in lots of places with NFC; the logic is "we want only one entry FileEntry in this map; let the first one win". Maybe most places would prefer a functionality change though, and, either way, the DenseMaps that need this unique-by-FileEntry* behaviour should probably be the ones using a custom DenseMapInfo.

[dexonsmith]

clang/include/clang/Basic/SourceManager.h

135–139

It's possible this could be factored out as a follow-up, and/or moved up to the Named ContentCache level. (Not sure... asking a question really...)

147–163

Have you thought about whether it makes sense for these fields to be shared for all FileEntryRefs to the same FileEntry? (Maybe it does! just checking)

261–263

I think this patch should (or does?) implement this FIXME.

265–268

I think you can delete this field. You're effectively implementing the FIXME.

[dexonsmith]

clang/include/clang/Basic/SourceManager.h

652–662

It feels expensive to have both of these maps. I wonder if instead we could do something like:

DenseMap<const FileEntry*, TinyPtrSet<NamedContentCache*>> FirstFileInfo;

I.e., lookup by FileEntry*, then linear search for the right FileEntryRef.

Similar idea: just point at NamedContentCache* directly here, but add NamedContentCache *NamedContentCache::Next to turn it into a linked list. Also lookup by FileEntry* and then a linear search for the right ref.

Note that FileInfo itself would have a direct pointer to the right thing; no need for a linear search.

[benlangmuir]

Thanks for the timely review!

the DenseMaps that need this unique-by-FileEntry* behaviour should probably be the ones using a custom DenseMapInfo.

Yeah, that's the way I'm currently leaning. Make the default for DenseMap and == be path equality and have a separate DenseMapInfo and isSameFileEntry for cases that want it. Thankfully there seems to be very little code depending on either of these. Though if I take your suggestion for FileInfos it will avoid needing a DenseMap<FileInfoRef in this patch specifically.

clang/include/clang/Basic/SourceManager.h

135–139

I think this belongs here. It is used to lazily get the contents of the file (see the getBuffer functions).

147–163

Yes, I think this split actually makes the behaviour clearer. The remaining fields are related to the contents, while the extracted fields are for the name. You only need one SourceLineCache, etc. for one set of file contents.

261–263

I think it can still be None/nullptr for some buffers. I'll verify that. IIRC the trick to removing Filename is to create virtual file refs in some places that currently don't have one.

652–662

Yeah, the TinyPtrSet approach here is something I thought about. I started with the two DenseMaps since it's simpler, but I can look at this again. Probably either of your suggestions are faster in practice, even if they have a worse worst case in theory, though I'll try to confirm that before committing to one or the other.

[dexonsmith]

clang/include/clang/Basic/SourceManager.h

261–263

Oh, maybe you're right. But if you're able to implement, it might help pay for some of the memory overhead of your patch.

[dexonsmith]

clang/include/clang/Basic/SourceManager.h

135–139

You're right. I wonder what if that laziness is inherently load-bearing. Seems odd that clang would want to create a FileID without very quickly trying to open it. But maybe that's important somewhere/somehow. Certainly off-topic for this patch though.

[bnbarham]

clang/include/clang/Basic/SourceManager.h

147–163

Makes sense to me. Might be worth adding a comment for that when you're done + fixing up the comment on ContentsEntry since it still references Entry (which I assume is what OrigEntry used to be called?).

314

I believe NamedContentCache can be const here now that we're not setting its filename.

clang/include/clang/Basic/FileEntry.h

private:
   friend class FileMgr::MapEntryOptionalStorage<FileEntryRef>;
   struct optional_none_tag {};
 
   // Private constructor for use by OptionalStorage.
   FileEntryRef(optional_none_tag) : ME(nullptr) {}
   bool hasOptionalValue() const { return ME; }
 
   friend struct llvm::DenseMapInfo<FileEntryRef>;
+  friend struct FileEntryRefSameRefDenseMapInfo;
   struct dense_map_empty_tag {};
   struct dense_map_tombstone_tag {};
 
   // Private constructors for use by DenseMapInfo.
   FileEntryRef(dense_map_empty_tag)
       : ME(llvm::DenseMapInfo<const MapEntry *>::getEmptyKey()) {}
   FileEntryRef(dense_map_tombstone_tag)
       : ME(llvm::DenseMapInfo<const MapEntry *>::getTombstoneKey()) {}
static bool isEqual(clang::FileEntryRef LHS, clang::FileEntryRef RHS) {
     return LHS == RHS;
   }
 };
 
 } // end namespace llvm
 
 namespace clang {
 
+/// Specialization of \c DenseMapInfo for \c FileEntryRef that treats different
+/// paths to the same underlying file independently, as with \c isSameRef.
+struct FileEntryRefSameRefDenseMapInfo {
+  static inline FileEntryRef getEmptyKey() {
+    return FileEntryRef(FileEntryRef::dense_map_empty_tag());
+  }
+
+  static inline clang::FileEntryRef getTombstoneKey() {
+    return clang::FileEntryRef(clang::FileEntryRef::dense_map_tombstone_tag());
+  }
+
+  static unsigned getHashValue(clang::FileEntryRef Val) {
+    return hash_value(Val.ME);
+  }
+
+  static bool isEqual(clang::FileEntryRef LHS, clang::FileEntryRef RHS) {
+    return LHS.isSameRef(RHS);
+  }
+};
+
 /// Wrapper around Optional<FileEntryRef> that degrades to 'const FileEntry*',
 /// facilitating incremental patches to propagate FileEntryRef.
 ///
 /// This class can be used as return value or field where it's convenient for
 /// an Optional<FileEntryRef> to degrade to a 'const FileEntry*'. The purpose
 /// is to avoid code churn due to dances like the following:
 /// \code
 /// // Old code.

clang/include/clang/Basic/SourceManager.h

 private:
   /// First element is the size, followed by elements at off-by-one indexes.
   unsigned *Storage = nullptr;
 };
 
 /// One instance of this struct is kept for every file loaded or used.
 ///
 /// This object owns the MemoryBuffer object.
-class alignas(8) ContentCache {
+class ContentCache {
   /// The actual buffer containing the characters from the input
   /// file.
   mutable std::unique_ptr<llvm::MemoryBuffer> Buffer;
 
-  friend class FileInfo;
-
-  /// Reference to the file entry representing this ContentCache.
-  ///
-  /// This reference does not own the FileEntry object.
-  ///
-  /// It is possible for this to be NULL if the ContentCache encapsulates
-  /// an imaginary text buffer.
-  ///
-  /// FIXME: Make non-optional using a virtual file as needed, remove \c
-  /// Filename and use \c OrigEntry.getNameAsRequested() instead.
-  OptionalFileEntryRefDegradesToFileEntryPtr OrigEntry;
-
-  /// The filename that is used to access OrigEntry.
-  ///
-  /// FIXME: Remove this once OrigEntry is a FileEntryRef with a stable name.
-  StringRef Filename;
-
 public:
   /// References the file which the contents were actually loaded from.
   ///
   /// Can be different from 'Entry' if we overridden the contents of one file
   /// with the contents of another file.
   const FileEntry *ContentsEntry;
 
   /// A bump pointer allocated array of offsets for each source line.
   ///
   /// This is lazily computed.  The lines are owned by the SourceManager
   /// BumpPointerAllocator object.
   mutable LineOffsetMapping SourceLineCache;
 
   /// Indicates whether the buffer itself was provided to override
   /// the actual file contents.
   ///
   /// When true, the original entry may be a virtual file that does not
   /// exist.
   unsigned BufferOverridden : 1;
 
   /// True if this content cache was initially created for a source file
   /// 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;
 
   mutable unsigned IsBufferInvalid : 1;
 
   ContentCache()
-      : OrigEntry(None), ContentsEntry(nullptr), BufferOverridden(false),
-        IsFileVolatile(false), IsTransient(false), IsBufferInvalid(false) {}
+      : ContentsEntry(nullptr), BufferOverridden(false), IsFileVolatile(false),
+        IsTransient(false), IsBufferInvalid(false) {}
 
-  ContentCache(FileEntryRef Ent) : ContentCache(Ent, Ent) {}
+  // FIXME: remove
+  ContentCache(FileEntryRef Ent) = delete;
 
-  ContentCache(FileEntryRef Ent, const FileEntry *contentEnt)
-      : OrigEntry(Ent), ContentsEntry(contentEnt), BufferOverridden(false),
+  ContentCache(const FileEntry *contentEnt)
+      : ContentsEntry(contentEnt), BufferOverridden(false),
         IsFileVolatile(false), IsTransient(false), IsBufferInvalid(false) {}
 
   /// Create a copy of \p Other with an unowned reference to its buffer as if
   /// set using \c setUnownedBuffer.
   static ContentCache createUnownedCopy(const ContentCache &Other);
 
   ContentCache(ContentCache &&RHS) = default;
   ContentCache(const ContentCache &RHS) = delete;
if (B)
       setBuffer(llvm::MemoryBuffer::getMemBuffer(*B));
   }
 
   // If BufStr has an invalid BOM, returns the BOM name; otherwise, returns
   // nullptr
   static const char *getInvalidBOM(StringRef BufStr);
 };
 
-// Assert that the \c ContentCache objects will always be 8-byte aligned so
+/// A \c ContentCache and the \c FileEntryRef that represents its name, needed
+/// by \c FileInfo. This is stored out of line to keep \c SLocEntry small.
+struct alignas(8) NamedContentCache {
+  /// The content cache entry.
+  ContentCache *Cache;
+
+  /// Reference to the file entry representing \c ContentCache.
+  ///
+  /// This reference does not own the FileEntry object.
+  ///
+  /// It is possible for this to be NULL if the ContentCache encapsulates
+  /// an imaginary text buffer.
+  ///
+  /// FIXME: Make non-optional using a virtual file as needed, remove \c
+  /// Filename and use \c OrigEntry.getNameAsRequested() instead.
+  OptionalFileEntryRefDegradesToFileEntryPtr OrigEntry;
+
+  /// The filename that is used to access OrigEntry.
+  ///
+  /// FIXME: Remove this once OrigEntry is a FileEntryRef with a stable name.
+  StringRef Filename;
+};
+
+// Assert that the \c NamedContentCache objects will always be 8-byte aligned so
 // that we can pack 3 bits of integer into pointers to such objects.
-static_assert(alignof(ContentCache) >= 8,
-              "ContentCache must be 8-byte aligned.");
+static_assert(alignof(NamedContentCache) >= 8,
+              "NamedContentCache must be 8-byte aligned.");
 
 /// Information about a FileID, basically just the logical file
 /// that it represents and include stack information.
 ///
 /// Each FileInfo has include stack information, indicating where it came
 /// from. This information encodes the \#include chain that a token was
 /// expanded from. The main include file has an invalid IncludeLoc.
 ///
class FileInfo {
   /// preprocessing of this \#include, including this SLocEntry.
   ///
   /// Zero means the preprocessor didn't provide such info for this SLocEntry.
   unsigned NumCreatedFIDs : 31;
 
   /// Whether this FileInfo has any \#line directives.
   unsigned HasLineDirectives : 1;
 
-  /// The content cache and the characteristic of the file.
-  llvm::PointerIntPair<const ContentCache *, 3, CharacteristicKind>
+  /// The name, content cache and the characteristic of the file.
+  llvm::PointerIntPair<const NamedContentCache *, 3, CharacteristicKind>
       ContentAndKind;
 
 public:
   /// Return a FileInfo object.
-  static FileInfo get(SourceLocation IL, ContentCache &Con,
-                      CharacteristicKind FileCharacter, StringRef Filename) {
+  static FileInfo get(SourceLocation IL, NamedContentCache &Con,
+                      CharacteristicKind FileCharacter) {
     FileInfo X;
     X.IncludeLoc = IL;
     X.NumCreatedFIDs = 0;
     X.HasLineDirectives = false;
     X.ContentAndKind.setPointer(&Con);
     X.ContentAndKind.setInt(FileCharacter);
-    Con.Filename = Filename;
     return X;
   }
 
   SourceLocation getIncludeLoc() const {
     return IncludeLoc;
   }
 
-  const ContentCache &getContentCache() const {
+  const NamedContentCache &getNamedContentCache() const {
     return *ContentAndKind.getPointer();
   }
 
+  const ContentCache &getContentCache() const {
+    return *getNamedContentCache().Cache;
+  }
+
   /// Return whether this is a system header or not.
   CharacteristicKind getFileCharacteristic() const {
     return ContentAndKind.getInt();
   }
 
   /// Return true if this FileID has \#line directives in it.
   bool hasLineDirectives() const { return HasLineDirectives; }
 
   /// Set the flag that indicates that this FileID has
   /// line table entries associated with it.
   void setHasLineDirectives() { HasLineDirectives = true; }
 
   /// Returns the name of the file that was used when the file was loaded from
   /// the underlying file system.
-  StringRef getName() const { return getContentCache().Filename; }
+  StringRef getName() const { return getNamedContentCache().Filename; }
 
   OptionalFileEntryRefDegradesToFileEntryPtr getOrigEntry() const {
-    return getContentCache().OrigEntry;
+    return getNamedContentCache().OrigEntry;
   }
 };
 
 /// Each ExpansionInfo encodes the expansion location - where
 /// the token was ultimately expanded, and the SpellingLoc - where the actual
 /// character data for the token came from.
 class ExpansionInfo {
   // Really these are all SourceLocations.

 class SourceManager : public RefCountedBase<SourceManager> {
   /// DiagnosticsEngine object.
   DiagnosticsEngine &Diag;
 
   FileManager &FileMgr;
 
   mutable llvm::BumpPtrAllocator ContentCacheAlloc;
 
+  llvm::DenseMap<FileEntryRef, SrcMgr::NamedContentCache *,
+                 FileEntryRefSameRefDenseMapInfo>
+      NamedFileInfos;
+
   /// Memoized information about all of the files tracked by this
   /// SourceManager.
   ///
   /// This map allows us to merge ContentCache entries based
   /// on their FileEntry*.  All ContentCache objects will thus have unique,
   /// non-null, FileEntry pointers.
   llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*> FileInfos;
 
   /// True if the ContentCache for files that are overridden by other
   /// files, should report the original file name. Defaults to true.
   bool OverridenFilesKeepOriginalName = true;
 
   /// True if non-system source files should be treated as volatile
   /// (likely to change while trying to use them). Defaults to false.
   bool UserFilesAreVolatile;
class SourceManager : public RefCountedBase<SourceManager> {
 
   /// Return the cache entry for comparing the given file IDs
   /// for isBeforeInTranslationUnit.
   InBeforeInTUCacheEntry &getInBeforeInTUCache(FileID LFID, FileID RFID) const;
 
   // Cache for the "fake" buffer used for error-recovery purposes.
   mutable std::unique_ptr<llvm::MemoryBuffer> FakeBufferForRecovery;
 
-  mutable std::unique_ptr<SrcMgr::ContentCache> FakeContentCacheForRecovery;
+  mutable std::unique_ptr<SrcMgr::NamedContentCache>
+      FakeContentCacheForRecovery;
 
   mutable std::unique_ptr<SrcMgr::SLocEntry> FakeSLocEntryForRecovery;
 
   /// Lazily computed map of macro argument chunks to their expanded
   /// source location.
   using MacroArgsMap = std::map<unsigned, SourceLocation>;
 
   mutable llvm::DenseMap<FileID, std::unique_ptr<MacroArgsMap>>
public:
   /// \return Location of the top-level macro caller.
   SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const;
 
 private:
   friend class ASTReader;
   friend class ASTWriter;
 
   llvm::MemoryBufferRef getFakeBufferForRecovery() const;
-  SrcMgr::ContentCache &getFakeContentCacheForRecovery() const;
+  SrcMgr::NamedContentCache &getFakeContentCacheForRecovery() const;
 
   const SrcMgr::SLocEntry &loadSLocEntry(unsigned Index, bool *Invalid) const;
 
   const SrcMgr::SLocEntry *getSLocEntryOrNull(FileID FID) const {
     bool Invalid = false;
     const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
     return Invalid ? nullptr : &Entry;
   }
private:
   /// no next one.
   FileID getNextFileID(FileID FID) const;
 
   /// Create a new fileID for the specified ContentCache and
   /// include position.
   ///
   /// This works regardless of whether the ContentCache corresponds to a
   /// file or some other input source.
-  FileID createFileIDImpl(SrcMgr::ContentCache &File, StringRef Filename,
+  FileID createFileIDImpl(SrcMgr::NamedContentCache &File,
                           SourceLocation IncludePos,
                           SrcMgr::CharacteristicKind DirCharacter, int LoadedID,
                           SourceLocation::UIntTy LoadedOffset);
 
-  SrcMgr::ContentCache &getOrCreateContentCache(FileEntryRef SourceFile,
+  SrcMgr::NamedContentCache &getOrCreateContentCache(FileEntryRef SourceFile,
                                                      bool isSystemFile = false);
 
   /// Create a new ContentCache for the specified  memory buffer.
-  SrcMgr::ContentCache &
+  SrcMgr::NamedContentCache &
   createMemBufferContentCache(std::unique_ptr<llvm::MemoryBuffer> Buf);
 
   FileID getFileIDSlow(SourceLocation::UIntTy SLocOffset) const;
   FileID getFileIDLocal(SourceLocation::UIntTy SLocOffset) const;
   FileID getFileIDLoaded(SourceLocation::UIntTy SLocOffset) const;
 
   SourceLocation getExpansionLocSlowCase(SourceLocation Loc) const;
   SourceLocation getSpellingLocSlowCase(SourceLocation Loc) const;

clang/lib/Basic/SourceManager.cpp

bool SourceManager::isMainFile(const FileEntry &SourceFile) {
   assert(MainFileID.isValid() && "expected initialized SourceManager");
   if (auto *FE = getFileEntryForID(MainFileID))
     return FE->getUID() == SourceFile.getUID();
   return false;
 }
 
 ContentCache ContentCache::createUnownedCopy(const ContentCache &Other) {
   ContentCache Clone;
-  Clone.OrigEntry = Other.OrigEntry;
   Clone.ContentsEntry = Other.ContentsEntry;
   Clone.BufferOverridden = Other.BufferOverridden;
   Clone.IsFileVolatile = Other.IsFileVolatile;
   Clone.IsTransient = Other.IsTransient;
   Clone.setUnownedBuffer(Other.getBufferIfLoaded());
   return Clone;
 }
 
void SourceManager::initializeForReplay(const SourceManager &Old) {
   for (auto &FileInfo : Old.FileInfos) {
     SrcMgr::ContentCache *&Slot = FileInfos[FileInfo.first];
     if (Slot)
       continue;
     Slot = CloneContentCache(FileInfo.second);
   }
 }
 
-ContentCache &SourceManager::getOrCreateContentCache(FileEntryRef FileEnt,
-                                                     bool isSystemFile) {
+NamedContentCache &
+SourceManager::getOrCreateContentCache(FileEntryRef SourceFile,
+  NamedContentCache *&NamedEntry = NamedFileInfos[SourceFile];
+  if (NamedEntry)
+    return *NamedEntry;
+
+  NamedEntry = ContentCacheAlloc.Allocate<NamedContentCache>();
+  NamedEntry->OrigEntry = SourceFile;
+  NamedEntry->Filename = SourceFile.getName();
+
+  if (OverriddenFilesInfo && !OverridenFilesKeepOriginalName) {
+    auto overI = OverriddenFilesInfo->OverriddenFiles.find(SourceFile);
+    if (overI != OverriddenFilesInfo->OverriddenFiles.end()) {
+      NamedEntry->OrigEntry = overI->second;
+      NamedEntry->Filename = overI->second.getName();
+    }
+  }
+
   // Do we already have information about this file?
-  ContentCache *&Entry = FileInfos[FileEnt];
-  if (Entry)
-    return *Entry;
+  ContentCache *&Entry = FileInfos[&SourceFile.getFileEntry()];
+  if (Entry) {
+    NamedEntry->Cache = Entry;
+    return *NamedEntry;
+  }
 
   // Nope, create a new Cache entry.
+
   Entry = ContentCacheAlloc.Allocate<ContentCache>();
+  NamedEntry->Cache = Entry;
 
   if (OverriddenFilesInfo) {
     // If the file contents are overridden with contents from another file,
     // pass that file to ContentCache.
-    auto overI = OverriddenFilesInfo->OverriddenFiles.find(FileEnt);
+    auto overI = OverriddenFilesInfo->OverriddenFiles.find(SourceFile);
     if (overI == OverriddenFilesInfo->OverriddenFiles.end())
-      new (Entry) ContentCache(FileEnt);
+      new (Entry) ContentCache(&SourceFile.getFileEntry());
     else
-      new (Entry) ContentCache(OverridenFilesKeepOriginalName ? FileEnt
-                                                              : overI->second,
-                               overI->second);
+      new (Entry) ContentCache(&overI->second.getFileEntry());
   } else {
-    new (Entry) ContentCache(FileEnt);
+    new (Entry) ContentCache(&SourceFile.getFileEntry());
   }
 
   Entry->IsFileVolatile = UserFilesAreVolatile && !isSystemFile;
   Entry->IsTransient = FilesAreTransient;
-  Entry->BufferOverridden |= FileEnt.isNamedPipe();
+  Entry->BufferOverridden |= SourceFile.isNamedPipe();
 
-  return *Entry;
+  return *NamedEntry;
 }
 
 /// Create a new ContentCache for the specified memory buffer.
 /// This does no caching.
-ContentCache &SourceManager::createMemBufferContentCache(
+NamedContentCache &SourceManager::createMemBufferContentCache(
     std::unique_ptr<llvm::MemoryBuffer> Buffer) {
   // Add a new ContentCache to the MemBufferInfos list and return it.
-  ContentCache *Entry = ContentCacheAlloc.Allocate<ContentCache>();
-  new (Entry) ContentCache();
+  NamedContentCache *NamedEntry =
+      new (ContentCacheAlloc.Allocate<NamedContentCache>()) NamedContentCache();
+  NamedEntry->Filename = Buffer->getBufferIdentifier();
+  ContentCache *Entry =
+      new (ContentCacheAlloc.Allocate<ContentCache>()) ContentCache();
   MemBufferInfos.push_back(Entry);
   Entry->setBuffer(std::move(Buffer));
-  return *Entry;
+  NamedEntry->Cache = Entry;
+  return *NamedEntry;
 }
 
 const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index,
                                                       bool *Invalid) const {
   assert(!SLocEntryLoaded[Index]);
   if (ExternalSLocEntries->ReadSLocEntry(-(static_cast<int>(Index) + 2))) {
     if (Invalid)
       *Invalid = true;
     // If the file of the SLocEntry changed we could still have loaded it.
     if (!SLocEntryLoaded[Index]) {
       // Try to recover; create a SLocEntry so the rest of clang can handle it.
       if (!FakeSLocEntryForRecovery)
         FakeSLocEntryForRecovery = std::make_unique<SLocEntry>(SLocEntry::get(
             0, FileInfo::get(SourceLocation(), getFakeContentCacheForRecovery(),
-                             SrcMgr::C_User, "")));
+                             SrcMgr::C_User)));
       return *FakeSLocEntryForRecovery;
     }
   }
 
   return LoadedSLocEntryTable[Index];
 }
 
 std::pair<int, SourceLocation::UIntTy>
if (!FakeBufferForRecovery)
     FakeBufferForRecovery =
         llvm::MemoryBuffer::getMemBuffer("<<<INVALID BUFFER>>");
 
   return *FakeBufferForRecovery;
 }
 
 /// As part of recovering from missing or changed content, produce a
 /// fake content cache.
-SrcMgr::ContentCache &SourceManager::getFakeContentCacheForRecovery() const {
+SrcMgr::NamedContentCache &
+SourceManager::getFakeContentCacheForRecovery() const {
   if (!FakeContentCacheForRecovery) {
-    FakeContentCacheForRecovery = std::make_unique<SrcMgr::ContentCache>();
-    FakeContentCacheForRecovery->setUnownedBuffer(getFakeBufferForRecovery());
+    FakeContentCacheForRecovery = std::make_unique<SrcMgr::NamedContentCache>();
+    FakeContentCacheForRecovery->Cache = new SrcMgr::ContentCache();
+    FakeContentCacheForRecovery->Cache->setUnownedBuffer(
+        getFakeBufferForRecovery());
   }
   return *FakeContentCacheForRecovery;
 }
 
 /// 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 createFileID(SourceFile->getLastRef(), IncludePos, FileCharacter,
                       LoadedID, LoadedOffset);
 }
 
 FileID SourceManager::createFileID(FileEntryRef SourceFile,
                                    SourceLocation IncludePos,
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID,
                                    SourceLocation::UIntTy LoadedOffset) {
-  SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile,
-                                                     isSystem(FileCharacter));
+  SrcMgr::NamedContentCache &IR =
+      getOrCreateContentCache(SourceFile, isSystem(FileCharacter));
 
   // If this is a named pipe, immediately load the buffer to ensure subsequent
   // calls to ContentCache::getSize() are accurate.
-  if (IR.ContentsEntry->isNamedPipe())
-    (void)IR.getBufferOrNone(Diag, getFileManager(), SourceLocation());
+  if (IR.Cache->ContentsEntry->isNamedPipe())
+    (void)IR.Cache->getBufferOrNone(Diag, getFileManager(), SourceLocation());
 
-  return createFileIDImpl(IR, SourceFile.getName(), IncludePos, FileCharacter,
-                          LoadedID, LoadedOffset);
+  return createFileIDImpl(IR, IncludePos, FileCharacter, LoadedID,
+                          LoadedOffset);
 }
 
 /// Create a new FileID that represents the specified memory buffer.
 ///
 /// This does no caching of the buffer and takes ownership of the
 /// MemoryBuffer, so only pass a MemoryBuffer to this once.
 FileID SourceManager::createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID,
                                    SourceLocation::UIntTy LoadedOffset,
                                    SourceLocation IncludeLoc) {
-  StringRef Name = Buffer->getBufferIdentifier();
-  return createFileIDImpl(createMemBufferContentCache(std::move(Buffer)), Name,
+  return createFileIDImpl(createMemBufferContentCache(std::move(Buffer)),
                           IncludeLoc, FileCharacter, LoadedID, LoadedOffset);
 }
 
 /// 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 SourceManager::createFileID(const llvm::MemoryBufferRef &Buffer,
SourceManager::getOrCreateFileID(const FileEntry *SourceFile,
   FileID ID = translateFile(SourceFile);
   return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
             FileCharacter);
 }
 
 /// createFileID - Create a new FileID for the specified ContentCache and
 /// include position.  This works regardless of whether the ContentCache
 /// corresponds to a file or some other input source.
-FileID SourceManager::createFileIDImpl(ContentCache &File, StringRef Filename,
+FileID SourceManager::createFileIDImpl(NamedContentCache &File,
                                        SourceLocation IncludePos,
                                        SrcMgr::CharacteristicKind FileCharacter,
                                        int LoadedID,
                                        SourceLocation::UIntTy LoadedOffset) {
   if (LoadedID < 0) {
     assert(LoadedID != -1 && "Loading sentinel FileID");
     unsigned Index = unsigned(-LoadedID) - 2;
     assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
     assert(!SLocEntryLoaded[Index] && "FileID already loaded");
     LoadedSLocEntryTable[Index] = SLocEntry::get(
-        LoadedOffset, FileInfo::get(IncludePos, File, FileCharacter, Filename));
+        LoadedOffset, FileInfo::get(IncludePos, File, FileCharacter));
     SLocEntryLoaded[Index] = true;
     return FileID::get(LoadedID);
   }
-  unsigned FileSize = File.getSize();
+  unsigned FileSize = File.Cache->getSize();
   if (!(NextLocalOffset + FileSize + 1 > NextLocalOffset &&
         NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset)) {
     Diag.Report(IncludePos, diag::err_include_too_large);
     return FileID();
   }
-  LocalSLocEntryTable.push_back(
-      SLocEntry::get(NextLocalOffset,
-                     FileInfo::get(IncludePos, File, FileCharacter, Filename)));
+  LocalSLocEntryTable.push_back(SLocEntry::get(
+      NextLocalOffset, FileInfo::get(IncludePos, File, FileCharacter)));
   // We do a +1 here because we want a SourceLocation that means "the end of the
   // file", e.g. for the "no newline at the end of the file" diagnostic.
   NextLocalOffset += FileSize + 1;
 
   // Set LastFileIDLookup to the newly created file.  The next getFileID call is
   // almost guaranteed to be from that file.
   FileID FID = FileID::get(LocalSLocEntryTable.size()-1);
   return LastFileIDLookup = FID;
assert(NextLocalOffset + Length + 1 > NextLocalOffset &&
          "Ran out of source locations!");
   // See createFileID for that +1.
   NextLocalOffset += Length + 1;
   return SourceLocation::getMacroLoc(NextLocalOffset - (Length + 1));
 }
 
 llvm::Optional<llvm::MemoryBufferRef>
 SourceManager::getMemoryBufferForFileOrNone(const FileEntry *File) {
-  SrcMgr::ContentCache &IR = getOrCreateContentCache(File->getLastRef());
-  return IR.getBufferOrNone(Diag, getFileManager(), SourceLocation());
+  SrcMgr::NamedContentCache &IR = getOrCreateContentCache(File->getLastRef());
+  return IR.Cache->getBufferOrNone(Diag, getFileManager(), SourceLocation());
 }
 
 void SourceManager::overrideFileContents(
     const FileEntry *SourceFile, std::unique_ptr<llvm::MemoryBuffer> Buffer) {
-  SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile->getLastRef());
+  SrcMgr::NamedContentCache &IR =
+      getOrCreateContentCache(SourceFile->getLastRef());
 
-  IR.setBuffer(std::move(Buffer));
-  IR.BufferOverridden = true;
+  IR.Cache->setBuffer(std::move(Buffer));
+  IR.Cache->BufferOverridden = true;
 
   getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          FileEntryRef NewFile) {
   assert(SourceFile->getSize() == NewFile.getSize() &&
          "Different sizes, use the FileManager to create a virtual file with "
SourceManager::bypassFileContentsOverride(FileEntryRef File) {
   if (!BypassFile)
     return None;
 
   (void)getOrCreateContentCache(*BypassFile);
   return BypassFile;
 }
 
 void SourceManager::setFileIsTransient(const FileEntry *File) {
-  getOrCreateContentCache(File->getLastRef()).IsTransient = true;
+  getOrCreateContentCache(File->getLastRef()).Cache->IsTransient = true;
 }
 
 Optional<StringRef>
 SourceManager::getNonBuiltinFilenameForID(FileID FID) const {
   if (const SrcMgr::SLocEntry *Entry = getSLocEntryForFile(FID))
     if (Entry->getFile().getOrigEntry())
       return Entry->getFile().getName();
   return None;

clang/lib/Serialization/ASTReader.cpp

case SM_SLOC_FILE_ENTRY: {
     unsigned NumFileDecls = Record[7];
     if (NumFileDecls && ContextObj) {
       const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
       assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
       FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
                                                              NumFileDecls));
     }
 
-    const SrcMgr::ContentCache &ContentCache =
+    const SrcMgr::NamedContentCache &ContentCache =
         SourceMgr.getOrCreateContentCache(*File, isSystem(FileCharacter));
-    if (OverriddenBuffer && !ContentCache.BufferOverridden &&
-        ContentCache.ContentsEntry == FileInfo.getOrigEntry() &&
-        !ContentCache.getBufferIfLoaded()) {
+    if (OverriddenBuffer && !ContentCache.Cache->BufferOverridden &&
+        ContentCache.Cache->ContentsEntry == FileInfo.getOrigEntry() &&
+        !ContentCache.Cache->getBufferIfLoaded()) {
       auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
       if (!Buffer)
         return true;
       SourceMgr.overrideFileContents(*File, std::move(Buffer));
     }
 
     break;
   }

clang/test/Frontend/show-includes-symlink.c

+// REQUIRES: shell
+// RUN: rm -rf %t && mkdir %t
+// RUN: touch %t/A.h
+// RUN: ln -s A.h %t/B.h
+// RUN: %clang_cc1 -I%t --show-includes -E -o /dev/null %s 2>&1 | FileCheck %s
+
+#include "A.h"
+// CHECK: Note: including file: {{.*}}A.h
+#include "B.h"
+// CHECK: Note: including file: {{.*}}B.h

clang/test/Preprocessor/header-symlink.c

+// REQUIRES: shell
+// RUN: rm -rf %t && mkdir %t
+// RUN: touch %t/A.h
+// RUN: ln -s A.h %t/B.h
+// RUN: %clang_cc1 -I%t -E %s | FileCheck %s
+
+int A_table[] = {
+  #include "A.h"
+// CHECK: # 1 "{{.*}}A.h" 1
+};
+int B_table[] = {
+  #include "B.h"
+// CHECK: # 1 "{{.*}}B.h" 1
+};
+int A_table[] = {
+  #include "A.h"
+// CHECK: # 1 "{{.*}}A.h" 1
+};
 No newline at end of file