1 //===--- ModuleDependencyCollector.cpp - Collect module dependencies ------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Collect the dependencies of a set of modules. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/CharInfo.h" 14 #include "clang/Frontend/Utils.h" 15 #include "clang/Lex/Preprocessor.h" 16 #include "clang/Serialization/ASTReader.h" 17 #include "llvm/ADT/iterator_range.h" 18 #include "llvm/Config/llvm-config.h" 19 #include "llvm/Support/FileSystem.h" 20 #include "llvm/Support/Path.h" 21 #include "llvm/Support/raw_ostream.h" 22 23 using namespace clang; 24 25 namespace { 26 /// Private implementations for ModuleDependencyCollector 27 class ModuleDependencyListener : public ASTReaderListener { 28 ModuleDependencyCollector &Collector; 29 FileManager &FileMgr; 30 public: 31 ModuleDependencyListener(ModuleDependencyCollector &Collector, 32 FileManager &FileMgr) 33 : Collector(Collector), FileMgr(FileMgr) {} 34 bool needsInputFileVisitation() override { return true; } 35 bool needsSystemInputFileVisitation() override { return true; } 36 bool visitInputFile(StringRef Filename, bool IsSystem, bool IsOverridden, 37 bool IsExplicitModule) override { 38 // Run this through the FileManager in order to respect 'use-external-name' 39 // in case we have a VFS overlay. 40 if (auto FE = FileMgr.getOptionalFileRef(Filename)) 41 Filename = FE->getName(); 42 Collector.addFile(Filename); 43 return true; 44 } 45 }; 46 47 struct ModuleDependencyPPCallbacks : public PPCallbacks { 48 ModuleDependencyCollector &Collector; 49 SourceManager &SM; 50 ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector, 51 SourceManager &SM) 52 : Collector(Collector), SM(SM) {} 53 54 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, 55 StringRef FileName, bool IsAngled, 56 CharSourceRange FilenameRange, 57 OptionalFileEntryRef File, StringRef SearchPath, 58 StringRef RelativePath, const Module *Imported, 59 SrcMgr::CharacteristicKind FileType) override { 60 if (!File) 61 return; 62 Collector.addFile(File->getName()); 63 } 64 }; 65 66 struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks { 67 ModuleDependencyCollector &Collector; 68 ModuleDependencyMMCallbacks(ModuleDependencyCollector &Collector) 69 : Collector(Collector) {} 70 71 void moduleMapAddHeader(StringRef HeaderPath) override { 72 if (llvm::sys::path::is_absolute(HeaderPath)) 73 Collector.addFile(HeaderPath); 74 } 75 void moduleMapAddUmbrellaHeader(FileEntryRef Header) override { 76 moduleMapAddHeader(Header.getNameAsRequested()); 77 } 78 }; 79 80 } // namespace 81 82 void ModuleDependencyCollector::attachToASTReader(ASTReader &R) { 83 R.addListener( 84 std::make_unique<ModuleDependencyListener>(*this, R.getFileManager())); 85 } 86 87 void ModuleDependencyCollector::attachToPreprocessor(Preprocessor &PP) { 88 PP.addPPCallbacks(std::make_unique<ModuleDependencyPPCallbacks>( 89 *this, PP.getSourceManager())); 90 PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks( 91 std::make_unique<ModuleDependencyMMCallbacks>(*this)); 92 } 93 94 static bool isCaseSensitivePath(StringRef Path) { 95 SmallString<256> TmpDest = Path, UpperDest, RealDest; 96 // Remove component traversals, links, etc. 97 if (llvm::sys::fs::real_path(Path, TmpDest)) 98 return true; // Current default value in vfs.yaml 99 Path = TmpDest; 100 101 // Change path to all upper case and ask for its real path, if the latter 102 // exists and is equal to Path, it's not case sensitive. Default to case 103 // sensitive in the absence of realpath, since this is what the VFSWriter 104 // already expects when sensitivity isn't setup. 105 for (auto &C : Path) 106 UpperDest.push_back(toUppercase(C)); 107 if (!llvm::sys::fs::real_path(UpperDest, RealDest) && Path.equals(RealDest)) 108 return false; 109 return true; 110 } 111 112 void ModuleDependencyCollector::writeFileMap() { 113 if (Seen.empty()) 114 return; 115 116 StringRef VFSDir = getDest(); 117 118 // Default to use relative overlay directories in the VFS yaml file. This 119 // allows crash reproducer scripts to work across machines. 120 VFSWriter.setOverlayDir(VFSDir); 121 122 // Explicitly set case sensitivity for the YAML writer. For that, find out 123 // the sensitivity at the path where the headers all collected to. 124 VFSWriter.setCaseSensitivity(isCaseSensitivePath(VFSDir)); 125 126 // Do not rely on real path names when executing the crash reproducer scripts 127 // since we only want to actually use the files we have on the VFS cache. 128 VFSWriter.setUseExternalNames(false); 129 130 std::error_code EC; 131 SmallString<256> YAMLPath = VFSDir; 132 llvm::sys::path::append(YAMLPath, "vfs.yaml"); 133 llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::OF_TextWithCRLF); 134 if (EC) { 135 HasErrors = true; 136 return; 137 } 138 VFSWriter.write(OS); 139 } 140 141 std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src, 142 StringRef Dst) { 143 using namespace llvm::sys; 144 llvm::FileCollector::PathCanonicalizer::PathStorage Paths = 145 Canonicalizer.canonicalize(Src); 146 147 SmallString<256> CacheDst = getDest(); 148 149 if (Dst.empty()) { 150 // The common case is to map the virtual path to the same path inside the 151 // cache. 152 path::append(CacheDst, path::relative_path(Paths.CopyFrom)); 153 } else { 154 // When collecting entries from input vfsoverlays, copy the external 155 // contents into the cache but still map from the source. 156 if (!fs::exists(Dst)) 157 return std::error_code(); 158 path::append(CacheDst, Dst); 159 Paths.CopyFrom = Dst; 160 } 161 162 // Copy the file into place. 163 if (std::error_code EC = fs::create_directories(path::parent_path(CacheDst), 164 /*IgnoreExisting=*/true)) 165 return EC; 166 if (std::error_code EC = fs::copy_file(Paths.CopyFrom, CacheDst)) 167 return EC; 168 169 // Always map a canonical src path to its real path into the YAML, by doing 170 // this we map different virtual src paths to the same entry in the VFS 171 // overlay, which is a way to emulate symlink inside the VFS; this is also 172 // needed for correctness, not doing that can lead to module redefinition 173 // errors. 174 addFileMapping(Paths.VirtualPath, CacheDst); 175 return std::error_code(); 176 } 177 178 void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) { 179 if (insertSeen(Filename)) 180 if (copyToRoot(Filename, FileDst)) 181 HasErrors = true; 182 } 183