| //===--- ModuleDependencyCollector.cpp - Collect module dependencies ------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Collect the dependencies of a set of modules. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/Basic/CharInfo.h" |
| #include "clang/Frontend/Utils.h" |
| #include "clang/Lex/Preprocessor.h" |
| #include "clang/Serialization/ASTReader.h" |
| #include "llvm/ADT/iterator_range.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using namespace clang; |
| |
| namespace { |
| /// Private implementations for ModuleDependencyCollector |
| class ModuleDependencyListener : public ASTReaderListener { |
| ModuleDependencyCollector &Collector; |
| public: |
| ModuleDependencyListener(ModuleDependencyCollector &Collector) |
| : Collector(Collector) {} |
| bool needsInputFileVisitation() override { return true; } |
| bool needsSystemInputFileVisitation() override { return true; } |
| bool visitInputFile(StringRef Filename, bool IsSystem, bool IsOverridden, |
| bool IsExplicitModule) override { |
| Collector.addFile(Filename); |
| return true; |
| } |
| }; |
| |
| struct ModuleDependencyPPCallbacks : public PPCallbacks { |
| ModuleDependencyCollector &Collector; |
| SourceManager &SM; |
| ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector, |
| SourceManager &SM) |
| : Collector(Collector), SM(SM) {} |
| |
| void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, |
| StringRef FileName, bool IsAngled, |
| CharSourceRange FilenameRange, const FileEntry *File, |
| StringRef SearchPath, StringRef RelativePath, |
| const Module *Imported) override { |
| if (!File) |
| return; |
| Collector.addFile(File->getName()); |
| } |
| }; |
| |
| struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks { |
| ModuleDependencyCollector &Collector; |
| ModuleDependencyMMCallbacks(ModuleDependencyCollector &Collector) |
| : Collector(Collector) {} |
| |
| void moduleMapAddHeader(StringRef HeaderPath) override { |
| if (llvm::sys::path::is_absolute(HeaderPath)) |
| Collector.addFile(HeaderPath); |
| } |
| void moduleMapAddUmbrellaHeader(FileManager *FileMgr, |
| const FileEntry *Header) override { |
| StringRef HeaderFilename = Header->getName(); |
| moduleMapAddHeader(HeaderFilename); |
| // The FileManager can find and cache the symbolic link for a framework |
| // header before its real path, this means a module can have some of its |
| // headers to use other paths. Although this is usually not a problem, it's |
| // inconsistent, and not collecting the original path header leads to |
| // umbrella clashes while rebuilding modules in the crash reproducer. For |
| // example: |
| // ApplicationServices.framework/Frameworks/ImageIO.framework/ImageIO.h |
| // instead of: |
| // ImageIO.framework/ImageIO.h |
| // |
| // FIXME: this shouldn't be necessary once we have FileName instances |
| // around instead of FileEntry ones. For now, make sure we collect all |
| // that we need for the reproducer to work correctly. |
| StringRef UmbreallDirFromHeader = |
| llvm::sys::path::parent_path(HeaderFilename); |
| StringRef UmbrellaDir = Header->getDir()->getName(); |
| if (!UmbrellaDir.equals(UmbreallDirFromHeader)) { |
| SmallString<128> AltHeaderFilename; |
| llvm::sys::path::append(AltHeaderFilename, UmbrellaDir, |
| llvm::sys::path::filename(HeaderFilename)); |
| if (FileMgr->getFile(AltHeaderFilename)) |
| moduleMapAddHeader(AltHeaderFilename); |
| } |
| } |
| }; |
| |
| } |
| |
| // TODO: move this to Support/Path.h and check for HAVE_REALPATH? |
| static bool real_path(StringRef SrcPath, SmallVectorImpl<char> &RealPath) { |
| #ifdef LLVM_ON_UNIX |
| char CanonicalPath[PATH_MAX]; |
| |
| // TODO: emit a warning in case this fails...? |
| if (!realpath(SrcPath.str().c_str(), CanonicalPath)) |
| return false; |
| |
| SmallString<256> RPath(CanonicalPath); |
| RealPath.swap(RPath); |
| return true; |
| #else |
| // FIXME: Add support for systems without realpath. |
| return false; |
| #endif |
| } |
| |
| void ModuleDependencyCollector::attachToASTReader(ASTReader &R) { |
| R.addListener(llvm::make_unique<ModuleDependencyListener>(*this)); |
| } |
| |
| void ModuleDependencyCollector::attachToPreprocessor(Preprocessor &PP) { |
| PP.addPPCallbacks(llvm::make_unique<ModuleDependencyPPCallbacks>( |
| *this, PP.getSourceManager())); |
| PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks( |
| llvm::make_unique<ModuleDependencyMMCallbacks>(*this)); |
| } |
| |
| static bool isCaseSensitivePath(StringRef Path) { |
| SmallString<256> TmpDest = Path, UpperDest, RealDest; |
| // Remove component traversals, links, etc. |
| if (!real_path(Path, TmpDest)) |
| return true; // Current default value in vfs.yaml |
| Path = TmpDest; |
| |
| // Change path to all upper case and ask for its real path, if the latter |
| // exists and is equal to Path, it's not case sensitive. Default to case |
| // sensitive in the absense of realpath, since this is what the VFSWriter |
| // already expects when sensitivity isn't setup. |
| for (auto &C : Path) |
| UpperDest.push_back(toUppercase(C)); |
| if (real_path(UpperDest, RealDest) && Path.equals(RealDest)) |
| return false; |
| return true; |
| } |
| |
| void ModuleDependencyCollector::writeFileMap() { |
| if (Seen.empty()) |
| return; |
| |
| StringRef VFSDir = getDest(); |
| |
| // Default to use relative overlay directories in the VFS yaml file. This |
| // allows crash reproducer scripts to work across machines. |
| VFSWriter.setOverlayDir(VFSDir); |
| |
| // Do not ignore non existent contents otherwise we might skip something |
| // that should have been collected here. |
| VFSWriter.setIgnoreNonExistentContents(false); |
| |
| // Explicitly set case sensitivity for the YAML writer. For that, find out |
| // the sensitivity at the path where the headers all collected to. |
| VFSWriter.setCaseSensitivity(isCaseSensitivePath(VFSDir)); |
| |
| // Do not rely on real path names when executing the crash reproducer scripts |
| // since we only want to actually use the files we have on the VFS cache. |
| VFSWriter.setUseExternalNames(false); |
| |
| std::error_code EC; |
| SmallString<256> YAMLPath = VFSDir; |
| llvm::sys::path::append(YAMLPath, "vfs.yaml"); |
| llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::F_Text); |
| if (EC) { |
| HasErrors = true; |
| return; |
| } |
| VFSWriter.write(OS); |
| } |
| |
| bool ModuleDependencyCollector::getRealPath(StringRef SrcPath, |
| SmallVectorImpl<char> &Result) { |
| using namespace llvm::sys; |
| SmallString<256> RealPath; |
| StringRef FileName = path::filename(SrcPath); |
| std::string Dir = path::parent_path(SrcPath).str(); |
| auto DirWithSymLink = SymLinkMap.find(Dir); |
| |
| // Use real_path to fix any symbolic link component present in a path. |
| // Computing the real path is expensive, cache the search through the |
| // parent path directory. |
| if (DirWithSymLink == SymLinkMap.end()) { |
| if (!real_path(Dir, RealPath)) |
| return false; |
| SymLinkMap[Dir] = RealPath.str(); |
| } else { |
| RealPath = DirWithSymLink->second; |
| } |
| |
| path::append(RealPath, FileName); |
| Result.swap(RealPath); |
| return true; |
| } |
| |
| std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src, |
| StringRef Dst) { |
| using namespace llvm::sys; |
| |
| // We need an absolute src path to append to the root. |
| SmallString<256> AbsoluteSrc = Src; |
| fs::make_absolute(AbsoluteSrc); |
| // Canonicalize src to a native path to avoid mixed separator styles. |
| path::native(AbsoluteSrc); |
| // Remove redundant leading "./" pieces and consecutive separators. |
| AbsoluteSrc = path::remove_leading_dotslash(AbsoluteSrc); |
| |
| // Canonicalize the source path by removing "..", "." components. |
| SmallString<256> VirtualPath = AbsoluteSrc; |
| path::remove_dots(VirtualPath, /*remove_dot_dot=*/true); |
| |
| // If a ".." component is present after a symlink component, remove_dots may |
| // lead to the wrong real destination path. Let the source be canonicalized |
| // like that but make sure we always use the real path for the destination. |
| SmallString<256> CopyFrom; |
| if (!getRealPath(AbsoluteSrc, CopyFrom)) |
| CopyFrom = VirtualPath; |
| SmallString<256> CacheDst = getDest(); |
| |
| if (Dst.empty()) { |
| // The common case is to map the virtual path to the same path inside the |
| // cache. |
| path::append(CacheDst, path::relative_path(CopyFrom)); |
| } else { |
| // When collecting entries from input vfsoverlays, copy the external |
| // contents into the cache but still map from the source. |
| if (!fs::exists(Dst)) |
| return std::error_code(); |
| path::append(CacheDst, Dst); |
| CopyFrom = Dst; |
| } |
| |
| // Copy the file into place. |
| if (std::error_code EC = fs::create_directories(path::parent_path(CacheDst), |
| /*IgnoreExisting=*/true)) |
| return EC; |
| if (std::error_code EC = fs::copy_file(CopyFrom, CacheDst)) |
| return EC; |
| |
| // Always map a canonical src path to its real path into the YAML, by doing |
| // this we map different virtual src paths to the same entry in the VFS |
| // overlay, which is a way to emulate symlink inside the VFS; this is also |
| // needed for correctness, not doing that can lead to module redefinition |
| // errors. |
| addFileMapping(VirtualPath, CacheDst); |
| return std::error_code(); |
| } |
| |
| void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) { |
| if (insertSeen(Filename)) |
| if (copyToRoot(Filename, FileDst)) |
| HasErrors = true; |
| } |