Fix ownership of FileManager in Tools

[resistor]

Summary

Tooling suffered from a serious bug that caused double-destruction of FileManager objects. These objects were owned by the Tool, but then passed as raw pointers to the CompilerInstance which tried to take ownership of them.

This bug is asymptomatic today because of another bug of a horrible sequence of coincidences, which I discovered when trying to fix a different bug that perturbed the world enough to expose this.

[klimek]

Thx for fixing. What's the reason that the CompilerInstance wants ownership?

[resistor]

In D15918#320300, @klimek wrote:

Thx for fixing. What's the reason that the CompilerInstance wants ownership?

I'm not an expert on the ownership model here, but it appears that CompilerInstance expects to hold ownership with an IntrusiveRefCntPtr. It then hands out raw pointers to the objects created under it.

There's nothing to indicate that it expects sole ownership. The problem manifests here, however, because the of the transfer method which passed through a raw pointer, so the two shared owners can end up with different reference counts.

[klimek]

In D15918#320301, @resistor wrote:

In D15918#320300, @klimek wrote:

Thx for fixing. What's the reason that the CompilerInstance wants ownership?

I'm not an expert on the ownership model here, but it appears that CompilerInstance expects to hold ownership with an IntrusiveRefCntPtr. It then hands out raw pointers to the objects created under it.

There's nothing to indicate that it expects sole ownership. The problem manifests here, however, because the of the transfer method which passed through a raw pointer, so the two shared owners can end up with different reference counts.

I understand - my question is, why not instead take away ownership from CompilerInstance?

[resistor]

! In D15918#320308, @klimek wrote:

I understand - my question is, why not instead take away ownership from CompilerInstance?

That seemed like a much more logically disruptive change. I am not familiar with all the clients of CompilerInstance, and it's not clear to me that all of them want to take ownership of the FileManager.

[klimek]

In D15918#320579, @resistor wrote:

! In D15918#320308, @klimek wrote:

I understand - my question is, why not instead take away ownership from CompilerInstance?

That seemed like a much more logically disruptive change. I am not familiar with all the clients of CompilerInstance, and it's not clear to me that all of them want to take ownership of the FileManager.

Generally, it seems like FileManager should always outlive CompilerInstance.
As Chandler would say, "all uses of ref-counting in clang are bugs" - I won't go as far, but in this case I think he has a point...

[resistor]

I am not comfortable authoring a patch to do that, as I don't have a clear understanding of the clients involved, and have no means to verify its correctness.

[resistor]

I made an attempt to remove ownership from CompilerInstance, but ASTUnit has a massively complex relationship with FileManager, and foiled my attempt.

include/clang/Frontend/ASTUnit.h

Sema &getSema() const {
     return *TheSema;
   }
 
   const LangOptions &getLangOpts() const {
     assert(LangOpts && " ASTUnit does not have language options");
     return *LangOpts;
   }
   
-  const FileManager &getFileManager() const { return *FileMgr; }
-        FileManager &getFileManager()       { return *FileMgr; }
+  const IntrusiveRefCntPtr<FileManager> getFileManager() const {
+    return FileMgr;
+  }
+  IntrusiveRefCntPtr<FileManager> getFileManager() {
+    return FileMgr;
+  }
 
   const FileSystemOptions &getFileSystemOpts() const { return FileSystemOpts; }
 
   StringRef getOriginalSourceFileName() {
     return OriginalSourceFile;
   }
 
   ASTMutationListener *getASTMutationListener();
public:
   /// \param Diags - The diagnostics engine to use for reporting errors; its
   /// lifetime is expected to extend past that of the returned ASTUnit.
   //
   // FIXME: Move OnlyLocalDecls, UseBumpAllocator to setters on the ASTUnit, we
   // shouldn't need to specify them at construction time.
   static std::unique_ptr<ASTUnit> LoadFromCompilerInvocation(
       CompilerInvocation *CI,
       std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-      IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr,
+      IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
+      IntrusiveRefCntPtr<FileManager> FileMgr,
       bool OnlyLocalDecls = false, bool CaptureDiagnostics = false,
       unsigned PrecompilePreambleAfterNParses = 0,
       TranslationUnitKind TUKind = TU_Complete,
       bool CacheCodeCompletionResults = false,
       bool IncludeBriefCommentsInCodeCompletion = false,
       bool UserFilesAreVolatile = false);
 
   /// LoadFromCommandLine - Create an ASTUnit from a vector of command line
public:
   /// FIXME: The Diag, LangOpts, SourceMgr, FileMgr, StoredDiagnostics, and
   /// OwnedBuffers parameters are all disgusting hacks. They will go away.
   void CodeComplete(StringRef File, unsigned Line, unsigned Column,
                     ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros,
                     bool IncludeCodePatterns, bool IncludeBriefComments,
                     CodeCompleteConsumer &Consumer,
                     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                     DiagnosticsEngine &Diag, LangOptions &LangOpts,
-                    SourceManager &SourceMgr, FileManager &FileMgr,
+                    SourceManager &SourceMgr,
+                    IntrusiveRefCntPtr<FileManager> FileMgr,
                     SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
                     SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers);
 
   /// \brief Save this translation unit to a file with the given name.
   ///
   /// \returns true if there was a file error or false if the save was
   /// successful.
   bool Save(StringRef File);

include/clang/Frontend/CompilerInstance.h

public:
   }
   
   void resetAndLeakFileManager() {
     BuryPointer(FileMgr.get());
     FileMgr.resetWithoutRelease();
   }
 
   /// \brief Replace the current file manager and virtual file system.
-  void setFileManager(FileManager *Value);
+  void setFileManager(IntrusiveRefCntPtr<FileManager> Value);
 
   /// }
   /// @name Source Manager
   /// {
 
   bool hasSourceManager() const { return SourceMgr != nullptr; }
 
   /// Return the current source manager.

include/clang/Tooling/Tooling.h

 /// If your tool is based on FrontendAction, you should be deriving from
 /// FrontendActionFactory instead.
 class ToolAction {
 public:
   virtual ~ToolAction();
 
   /// \brief Perform an action for an invocation.
   virtual bool
-  runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files,
+  runInvocation(clang::CompilerInvocation *Invocation,
+                IntrusiveRefCntPtr<FileManager> Files,
                 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                 DiagnosticConsumer *DiagConsumer) = 0;
 };
 
 /// \brief Interface to generate clang::FrontendActions.
 ///
 /// Having a factory interface allows, for example, a new FrontendAction to be
 /// created for each translation unit processed by ClangTool.  This class is
 /// also a ToolAction which uses the FrontendActions created by create() to
 /// process each translation unit.
 class FrontendActionFactory : public ToolAction {
 public:
   ~FrontendActionFactory() override;
 
   /// \brief Invokes the compiler with a FrontendAction created by create().
-  bool runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files,
+  bool runInvocation(clang::CompilerInvocation *Invocation,
+                     IntrusiveRefCntPtr<FileManager> Files,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagConsumer) override;
 
   /// \brief Returns a new clang::FrontendAction.
   ///
   /// The caller takes ownership of the returned action.
   virtual clang::FrontendAction *create() = 0;
 };
public:
   /// Callers have to ensure that they are installed in a compatible location
   /// (see clang driver implementation) or mapped in via mapVirtualFile.
   /// \param FAction The action to be executed. Class takes ownership.
   /// \param Files The FileManager used for the execution. Class does not take
   /// ownership.
   /// \param PCHContainerOps The PCHContainerOperations for loading and creating
   /// clang modules.
   ToolInvocation(std::vector<std::string> CommandLine, FrontendAction *FAction,
-                 FileManager *Files,
+                 IntrusiveRefCntPtr<FileManager> Files,
                  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                      std::make_shared<PCHContainerOperations>());
 
   /// \brief Create a tool invocation.
   ///
   /// \param CommandLine The command line arguments to clang.
   /// \param Action The action to be executed.
   /// \param Files The FileManager used for the execution.
   /// \param PCHContainerOps The PCHContainerOperations for loading and creating
   /// clang modules.
   ToolInvocation(std::vector<std::string> CommandLine, ToolAction *Action,
-                 FileManager *Files,
+                 IntrusiveRefCntPtr<FileManager> Files,
                  std::shared_ptr<PCHContainerOperations> PCHContainerOps);
 
   ~ToolInvocation();
 
   /// \brief Set a \c DiagnosticConsumer to use during parsing.
   void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer) {
     this->DiagConsumer = DiagConsumer;
   }
private:
   bool runInvocation(const char *BinaryName,
                      clang::driver::Compilation *Compilation,
                      clang::CompilerInvocation *Invocation,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps);
 
   std::vector<std::string> CommandLine;
   ToolAction *Action;
   bool OwnsAction;
-  FileManager *Files;
+  IntrusiveRefCntPtr<FileManager> Files;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
   // Maps <file name> -> <file content>.
   llvm::StringMap<StringRef> MappedFileContents;
   DiagnosticConsumer *DiagConsumer;
 };
 
 /// \brief Utility to run a FrontendAction over a set of files.
 ///

lib/ARCMigrate/ARCMT.cpp

for (Rewriter::buffer_iterator
     newFname += "-trans";
     SmallString<512> newText;
     llvm::raw_svector_ostream vecOS(newText);
     buf.write(vecOS);
     std::unique_ptr<llvm::MemoryBuffer> memBuf(
         llvm::MemoryBuffer::getMemBufferCopy(
             StringRef(newText.data(), newText.size()), newFname));
     SmallString<64> filePath(file->getName());
-    Unit->getFileManager().FixupRelativePath(filePath);
+    Unit->getFileManager()->FixupRelativePath(filePath);
     Remapper.remap(filePath.str(), std::move(memBuf));
   }
 
   return false;
 }

lib/Frontend/ASTMerge.cpp

std::unique_ptr<ASTUnit> Unit =
                                  Diags, CI.getFileSystemOpts(), false);
 
     if (!Unit)
       continue;
 
     ASTImporter Importer(CI.getASTContext(), 
                          CI.getFileManager(),
                          Unit->getASTContext(), 
-                         Unit->getFileManager(),
+                         *Unit->getFileManager(),
                          /*MinimalImport=*/false);
 
     TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
     for (auto *D : TU->decls()) {
       // Don't re-import __va_list_tag, __builtin_va_list.
       if (const auto *ND = dyn_cast<NamedDecl>(D))
         if (IdentifierInfo *II = ND->getIdentifier())
           if (II->isStr("__va_list_tag") || II->isStr("__builtin_va_list"))

lib/Frontend/ASTUnit.cpp

std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
 
   AST->OnlyLocalDecls = OnlyLocalDecls;
   AST->CaptureDiagnostics = CaptureDiagnostics;
   AST->Diagnostics = Diags;
   IntrusiveRefCntPtr<vfs::FileSystem> VFS = vfs::getRealFileSystem();
   AST->FileMgr = new FileManager(FileSystemOpts, VFS);
   AST->UserFilesAreVolatile = UserFilesAreVolatile;
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
-                                     AST->getFileManager(),
+                                     *AST->getFileManager(),
                                      UserFilesAreVolatile);
   AST->HSOpts = new HeaderSearchOptions();
   AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
   AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,
                                          AST->getSourceManager(),
                                          AST->getDiagnostics(),
                                          AST->ASTFileLangOpts,
                                          /*Target=*/nullptr));
bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
   CleanTemporaryFiles();
 
   if (!OverrideMainBuffer) {
     checkAndRemoveNonDriverDiags(StoredDiagnostics);
     TopLevelDeclsInPreamble.clear();
   }
 
   // Create a file manager object to provide access to and cache the filesystem.
-  Clang->setFileManager(&getFileManager());
+  Clang->setFileManager(getFileManager());
   
   // Create the source manager.
   Clang->setSourceManager(&getSourceManager());
   
   // If the main file has been overridden due to the use of a preamble,
   // make that override happen and introduce the preamble.
   PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts();
   if (OverrideMainBuffer) {
bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
   llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
     ActCleanup(Act.get());
 
   if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
     goto error;
 
   if (SavedMainFileBuffer) {
     std::string ModName = getPreambleFile(this);
-    TranslateStoredDiagnostics(getFileManager(), getSourceManager(),
+    TranslateStoredDiagnostics(*getFileManager(), getSourceManager(),
                                PreambleDiagnostics, StoredDiagnostics);
   }
 
   if (!Act->Execute())
     goto error;
 
   transferASTDataFromCompilerInstance(*Clang);
   
ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
 
   // Configure the various subsystems.
   AST->TheSema.reset();
   AST->Ctx = nullptr;
   AST->PP = nullptr;
   AST->Reader = nullptr;
 
   // Create a file manager object to provide access to and cache the filesystem.
-  Clang->setFileManager(&AST->getFileManager());
+  Clang->setFileManager(AST->getFileManager());
   
   // Create the source manager.
   Clang->setSourceManager(&AST->getSourceManager());
 
   ASTFrontendAction *Act = Action;
 
   std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
   if (!Act) {
llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
     MemBufferCleanup(OverrideMainBuffer.get());
 
   return Parse(PCHContainerOps, std::move(OverrideMainBuffer));
 }
 
 std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
     CompilerInvocation *CI,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr,
+    IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
+    IntrusiveRefCntPtr<FileManager> FileMgr,
     bool OnlyLocalDecls, bool CaptureDiagnostics,
     unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
     bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
     bool UserFilesAreVolatile) {
   // Create the AST unit.
   std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
   ConfigureDiags(Diags, *AST, CaptureDiagnostics);
   AST->Diagnostics = Diags;

 
 void ASTUnit::CodeComplete(
     StringRef File, unsigned Line, unsigned Column,
     ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros,
     bool IncludeCodePatterns, bool IncludeBriefComments,
     CodeCompleteConsumer &Consumer,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr,
-    FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
+    IntrusiveRefCntPtr<FileManager> FileMgr,
+    SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
     SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
   if (!Invocation)
     return;
 
   SimpleTimer CompletionTimer(WantTiming);
   CompletionTimer.setOutput("Code completion @ " + File + ":" +
                             Twine(Line) + ":" + Twine(Column));
 
assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
          "Invocation must have exactly one source file!");
   assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST &&
          "FIXME: AST inputs not yet supported here!");
   assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR &&
          "IR inputs not support here!");
 
   
   // Use the source and file managers that we were given.
-  Clang->setFileManager(&FileMgr);
+  Clang->setFileManager(FileMgr);
   Clang->setSourceManager(&SourceMgr);
 
   // Remap files.
   PreprocessorOpts.clearRemappedFiles();
   PreprocessorOpts.RetainRemappedFileBuffers = true;
   for (const auto &RemappedFile : RemappedFiles) {
     PreprocessorOpts.addRemappedFile(RemappedFile.first, RemappedFile.second);
     OwnedBuffers.push_back(RemappedFile.second);

lib/Frontend/CompilerInstance.cpp

 
 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
   Diagnostics = Value;
 }
 
 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
 
-void CompilerInstance::setFileManager(FileManager *Value) {
+void CompilerInstance::setFileManager(IntrusiveRefCntPtr<FileManager> Value) {
   FileMgr = Value;
   if (Value)
     VirtualFileSystem = Value->getVirtualFileSystem();
   else
     VirtualFileSystem.reset();
 }
 
 void CompilerInstance::setSourceManager(SourceManager *Value) {

lib/Frontend/FrontendAction.cpp

if (!AST)
       goto failure;
 
     // Inform the diagnostic client we are processing a source file.
     CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
     HasBegunSourceFile = true;
 
     // Set the shared objects, these are reset when we finish processing the
     // file, otherwise the CompilerInstance will happily destroy them.
-    CI.setFileManager(&AST->getFileManager());
+    CI.setFileManager(AST->getFileManager());
     CI.setSourceManager(&AST->getSourceManager());
     CI.setPreprocessor(&AST->getPreprocessor());
     CI.setASTContext(&AST->getASTContext());
 
     setCurrentInput(Input, std::move(AST));
 
     // Initialize the action.
     if (!BeginSourceFileAction(CI, InputFile))

lib/Tooling/Tooling.cpp

 bool runToolOnCodeWithArgs(
     clang::FrontendAction *ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     const FileContentMappings &VirtualMappedFiles) {
 
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
+  IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
-  llvm::IntrusiveRefCntPtr<FileManager> Files(
+  IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef),
                             ToolAction, Files.get(), PCHContainerOps);
 
   SmallString<1024> CodeStorage;
   InMemoryFileSystem->addFile(FileNameRef, 0,
                               llvm::MemoryBuffer::getMemBuffer(
                                   Code.toNullTerminatedStringRef(CodeStorage)));
public:
 
   FrontendAction *create() override { return Action; }
 };
 
 }
 
 ToolInvocation::ToolInvocation(
     std::vector<std::string> CommandLine, ToolAction *Action,
-    FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
+    IntrusiveRefCntPtr<FileManager> Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false),
       Files(Files), PCHContainerOps(PCHContainerOps), DiagConsumer(nullptr) {}
 
 ToolInvocation::ToolInvocation(
     std::vector<std::string> CommandLine, FrontendAction *FAction,
-    FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
+    IntrusiveRefCntPtr<FileManager> Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)),
       Action(new SingleFrontendActionFactory(FAction)), OwnsAction(true),
       Files(Files), PCHContainerOps(PCHContainerOps), DiagConsumer(nullptr) {}
 
 ToolInvocation::~ToolInvocation() {
   if (OwnsAction)
     delete Action;
 }
if (Invocation->getHeaderSearchOpts().Verbose) {
     llvm::errs() << "\n";
   }
 
   return Action->runInvocation(Invocation, Files, PCHContainerOps,
                                DiagConsumer);
 }
 
 bool FrontendActionFactory::runInvocation(
-    CompilerInvocation *Invocation, FileManager *Files,
+    CompilerInvocation *Invocation, IntrusiveRefCntPtr<FileManager> Files,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticConsumer *DiagConsumer) {
   // Create a compiler instance to handle the actual work.
   clang::CompilerInstance Compiler(PCHContainerOps);
   Compiler.setInvocation(Invocation);
   Compiler.setFileManager(Files);
 
   // The FrontendAction can have lifetime requirements for Compiler or its

 namespace {
 
 class ASTBuilderAction : public ToolAction {
   std::vector<std::unique_ptr<ASTUnit>> &ASTs;
 
 public:
   ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
 
-  bool runInvocation(CompilerInvocation *Invocation, FileManager *Files,
+  bool runInvocation(CompilerInvocation *Invocation,
+                     IntrusiveRefCntPtr<FileManager> Files,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagConsumer) override {
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
         Invocation, PCHContainerOps,
         CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts(),
                                             DiagConsumer,
                                             /*ShouldOwnClient=*/false),
         Files);

tools/libclang/CIndex.cpp

 CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
 
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 
-  FileManager &FMgr = CXXUnit->getFileManager();
+  FileManager &FMgr = *CXXUnit->getFileManager();
   return const_cast<FileEntry *>(FMgr.getFile(file_name));
 }
 
 unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU,
                                             CXFile file) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return 0;
unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
                                             CXModule CXMod) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return 0;
   }
   if (!CXMod)
     return 0;
   Module *Mod = static_cast<Module*>(CXMod);
-  FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
+  FileManager &FileMgr = *cxtu::getASTUnit(TU)->getFileManager();
   ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
   return TopHeaders.size();
 }
 
 CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU,
                                       CXModule CXMod, unsigned Index) {
   if (isNotUsableTU(TU)) {
     LOG_BAD_TU(TU);
     return nullptr;
   }
   if (!CXMod)
     return nullptr;
   Module *Mod = static_cast<Module*>(CXMod);
-  FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
+  FileManager &FileMgr = *cxtu::getASTUnit(TU)->getFileManager();
 
   ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
   if (Index < TopHeaders.size())
     return const_cast<FileEntry *>(TopHeaders[Index]);
 
   return nullptr;
 }
 

tools/libclang/CIndexCodeCompletion.cpp

#endif
   }
 
   if (EnableLogging) {
     // FIXME: Add logging.
   }
 
   // Parse the resulting source file to find code-completion results.
   AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults(
-      &AST->getFileManager());
+      AST->getFileManager().get());
   Results->Results = nullptr;
   Results->NumResults = 0;
   
   // Create a code-completion consumer to capture the results.
   CodeCompleteOptions Opts;
   Opts.IncludeBriefComments = IncludeBriefComments;
   CaptureCompletionResults Capture(Opts, *Results, &TU);
 
   // Perform completion.
   AST->CodeComplete(complete_filename, complete_line, complete_column,
                     RemappedFiles, (options & CXCodeComplete_IncludeMacros),
                     (options & CXCodeComplete_IncludeCodePatterns),
                     IncludeBriefComments, Capture,
                     CXXIdx->getPCHContainerOperations(), *Results->Diag,
-                    Results->LangOpts, *Results->SourceMgr, *Results->FileMgr,
+                    Results->LangOpts, *Results->SourceMgr,
+                    AST->getFileManager(),
                     Results->Diagnostics, Results->TemporaryBuffers);
 
   Results->DiagnosticsWrappers.resize(Results->Diagnostics.size());
 
   // Keep a reference to the allocator used for cached global completions, so
   // that we can be sure that the memory used by our code completion strings
   // doesn't get freed due to subsequent reparses (while the code completion
   // results are still active).

tools/libclang/Indexing.cpp

static CXErrorCode clang_indexTranslationUnit_Impl(
   if (!Unit)
     return CXError_Failure;
 
   ASTUnit::ConcurrencyCheck Check(*Unit);
 
   if (const FileEntry *PCHFile = Unit->getPCHFile())
     IndexCtx->importedPCH(PCHFile);
 
-  FileManager &FileMgr = Unit->getFileManager();
+  FileManager &FileMgr = *Unit->getFileManager();
 
   if (Unit->getOriginalSourceFileName().empty())
     IndexCtx->enteredMainFile(nullptr);
   else
     IndexCtx->enteredMainFile(FileMgr.getFile(Unit->getOriginalSourceFileName()));
 
   IndexConsumer->Initialize(Unit->getASTContext());