Lex: Avoid MemoryBuffer* key in ExcludedPreprocessorDirectiveSkipMapping, NFC

[dexonsmith]

Summary

This is a prep patch for https://reviews.llvm.org/D66782, changing SourceManager to return Optional<MemoryBufferRef> instead of MemoryBuffer. With that change the address of the MemoryBuffer will be gone, so instead use the start of the buffer as the key for this map.

No functionality change intended.

Radar-Id: rdar://70139990

[arphaman]

clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp

224

Looking over the code this method doesn't seem necessary anymore. Can you get the buffer pointer in createFile down below, after llvm::MemoryBuffer::getMemBuffer(*Contents, Entry->getName(), /*RequiresNullTerminator=*/false) is constructed?

[dexonsmith]

Agreed, looks cleaner without the indirection.

[arphaman]

clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp

255

Buffer is private, does this work here, or do you need a friend? Either way, LGTM

[dexonsmith]

I cleaned up the access and removed getBufferPtr separately in d07b290e4b7c55823895e88b683de4178ffc66db, then landed my change in 69feac12d0539a7cc19cbda906d46f67029486e1.

clang/include/clang/Lex/PreprocessorExcludedConditionalDirectiveSkipMapping.h

 /// A mapping from an offset into a buffer to the number of bytes that can be
 /// skipped by the preprocessor when skipping over excluded conditional
 /// directive ranges.
 using PreprocessorSkippedRangeMapping = llvm::DenseMap<unsigned, unsigned>;
 
 /// The datastructure that holds the mapping between the active memory buffers
 /// and the individual skip mappings.
 using ExcludedPreprocessorDirectiveSkipMapping =
-    llvm::DenseMap<const llvm::MemoryBuffer *,
-                   const PreprocessorSkippedRangeMapping *>;
+    llvm::DenseMap<const char *, const PreprocessorSkippedRangeMapping *>;
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LEX_PREPROCESSOR_EXCLUDED_COND_DIRECTIVE_SKIP_MAPPING_H

clang/lib/Lex/PPDirectives.cpp

Optional<unsigned> Preprocessor::getSkippedRangeForExcludedConditionalBlock(
   if (!ExcludedConditionalDirectiveSkipMappings)
     return None;
   if (!HashLoc.isFileID())
     return None;
 
   std::pair<FileID, unsigned> HashFileOffset =
       SourceMgr.getDecomposedLoc(HashLoc);
   const llvm::MemoryBuffer *Buf = SourceMgr.getBuffer(HashFileOffset.first);
-  auto It = ExcludedConditionalDirectiveSkipMappings->find(Buf);
+  if (!Buf)
+    return None;
+  auto It =
+      ExcludedConditionalDirectiveSkipMappings->find(Buf->getBufferStart());
   if (It == ExcludedConditionalDirectiveSkipMappings->end())
     return None;
 
   const PreprocessorSkippedRangeMapping &SkippedRanges = *It->getSecond();
   // Check if the offset of '#' is mapped in the skipped ranges.
   auto MappingIt = SkippedRanges.find(HashFileOffset.second);
   if (MappingIt == SkippedRanges.end())
     return None;

clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp

public:
   MinimizedVFSFile(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                    llvm::vfs::Status Stat)
       : Buffer(std::move(Buffer)), Stat(std::move(Stat)) {}
 
   static llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
   create(const CachedFileSystemEntry *Entry,
          ExcludedPreprocessorDirectiveSkipMapping *PPSkipMappings);
 
   llvm::ErrorOr<llvm::vfs::Status> status() override { return Stat; }
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
             bool IsVolatile) override {
     return std::move(Buffer);
   }
 
   std::error_code close() override { return {}; }
llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>> MinimizedVFSFile::create(
   llvm::ErrorOr<StringRef> Contents = Entry->getContents();
   if (!Contents)
     return Contents.getError();
   auto Result = std::make_unique<MinimizedVFSFile>(
       llvm::MemoryBuffer::getMemBuffer(*Contents, Entry->getName(),
                                        /*RequiresNullTerminator=*/false),
       *Entry->getStatus());
   if (!Entry->getPPSkippedRangeMapping().empty() && PPSkipMappings)
-    (*PPSkipMappings)[Result->Buffer.get()] =
+    (*PPSkipMappings)[Result->Buffer->getBufferStart()] =
         &Entry->getPPSkippedRangeMapping();
   return llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>(
       std::unique_ptr<llvm::vfs::File>(std::move(Result)));
 }
 
 llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
 DependencyScanningWorkerFilesystem::openFileForRead(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
 
   const llvm::ErrorOr<const CachedFileSystemEntry *> Result =
       getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
   return MinimizedVFSFile::create(Result.get(), PPSkipMappings);
 }