1 //===--- DependencyFile.cpp - Generate dependency file --------------------===//
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 // This code generates dependency files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Frontend/Utils.h"
14 #include "clang/Basic/FileManager.h"
15 #include "clang/Basic/SourceManager.h"
16 #include "clang/Frontend/DependencyOutputOptions.h"
17 #include "clang/Frontend/FrontendDiagnostic.h"
18 #include "clang/Lex/DirectoryLookup.h"
19 #include "clang/Lex/ModuleMap.h"
20 #include "clang/Lex/PPCallbacks.h"
21 #include "clang/Lex/Preprocessor.h"
22 #include "clang/Serialization/ASTReader.h"
23 #include "llvm/ADT/StringSet.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/raw_ostream.h"
28 
29 using namespace clang;
30 
31 namespace {
32 struct DepCollectorPPCallbacks : public PPCallbacks {
33   DependencyCollector &DepCollector;
34   SourceManager &SM;
35   DiagnosticsEngine &Diags;
36   DepCollectorPPCallbacks(DependencyCollector &L, SourceManager &SM,
37                           DiagnosticsEngine &Diags)
38       : DepCollector(L), SM(SM), Diags(Diags) {}
39 
40   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
41                    SrcMgr::CharacteristicKind FileType,
42                    FileID PrevFID) override {
43     if (Reason != PPCallbacks::EnterFile)
44       return;
45 
46     // Dependency generation really does want to go all the way to the
47     // file entry for a source location to find out what is depended on.
48     // We do not want #line markers to affect dependency generation!
49     if (Optional<StringRef> Filename = SM.getNonBuiltinFilenameForID(
50             SM.getFileID(SM.getExpansionLoc(Loc))))
51       DepCollector.maybeAddDependency(
52           llvm::sys::path::remove_leading_dotslash(*Filename),
53           /*FromModule*/ false, isSystem(FileType), /*IsModuleFile*/ false,
54           /*IsMissing*/ false);
55   }
56 
57   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
58                    SrcMgr::CharacteristicKind FileType) override {
59     StringRef Filename =
60         llvm::sys::path::remove_leading_dotslash(SkippedFile.getName());
61     DepCollector.maybeAddDependency(Filename, /*FromModule=*/false,
62                                     /*IsSystem=*/isSystem(FileType),
63                                     /*IsModuleFile=*/false,
64                                     /*IsMissing=*/false);
65   }
66 
67   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
68                           StringRef FileName, bool IsAngled,
69                           CharSourceRange FilenameRange, const FileEntry *File,
70                           StringRef SearchPath, StringRef RelativePath,
71                           const Module *Imported,
72                           SrcMgr::CharacteristicKind FileType) override {
73     if (!File)
74       DepCollector.maybeAddDependency(FileName, /*FromModule*/false,
75                                      /*IsSystem*/false, /*IsModuleFile*/false,
76                                      /*IsMissing*/true);
77     // Files that actually exist are handled by FileChanged.
78   }
79 
80   void HasInclude(SourceLocation Loc, StringRef SpelledFilename, bool IsAngled,
81                   Optional<FileEntryRef> File,
82                   SrcMgr::CharacteristicKind FileType) override {
83     if (!File)
84       return;
85     StringRef Filename =
86         llvm::sys::path::remove_leading_dotslash(File->getName());
87     DepCollector.maybeAddDependency(Filename, /*FromModule=*/false,
88                                     /*IsSystem=*/isSystem(FileType),
89                                     /*IsModuleFile=*/false,
90                                     /*IsMissing=*/false);
91   }
92 
93   void EndOfMainFile() override { DepCollector.finishedMainFile(Diags); }
94 };
95 
96 struct DepCollectorMMCallbacks : public ModuleMapCallbacks {
97   DependencyCollector &DepCollector;
98   DepCollectorMMCallbacks(DependencyCollector &DC) : DepCollector(DC) {}
99 
100   void moduleMapFileRead(SourceLocation Loc, const FileEntry &Entry,
101                          bool IsSystem) override {
102     StringRef Filename = Entry.getName();
103     DepCollector.maybeAddDependency(Filename, /*FromModule*/false,
104                                     /*IsSystem*/IsSystem,
105                                     /*IsModuleFile*/false,
106                                     /*IsMissing*/false);
107   }
108 };
109 
110 struct DepCollectorASTListener : public ASTReaderListener {
111   DependencyCollector &DepCollector;
112   DepCollectorASTListener(DependencyCollector &L) : DepCollector(L) { }
113   bool needsInputFileVisitation() override { return true; }
114   bool needsSystemInputFileVisitation() override {
115     return DepCollector.needSystemDependencies();
116   }
117   void visitModuleFile(StringRef Filename,
118                        serialization::ModuleKind Kind) override {
119     DepCollector.maybeAddDependency(Filename, /*FromModule*/true,
120                                    /*IsSystem*/false, /*IsModuleFile*/true,
121                                    /*IsMissing*/false);
122   }
123   bool visitInputFile(StringRef Filename, bool IsSystem,
124                       bool IsOverridden, bool IsExplicitModule) override {
125     if (IsOverridden || IsExplicitModule)
126       return true;
127 
128     DepCollector.maybeAddDependency(Filename, /*FromModule*/true, IsSystem,
129                                    /*IsModuleFile*/false, /*IsMissing*/false);
130     return true;
131   }
132 };
133 } // end anonymous namespace
134 
135 void DependencyCollector::maybeAddDependency(StringRef Filename,
136                                              bool FromModule, bool IsSystem,
137                                              bool IsModuleFile,
138                                              bool IsMissing) {
139   if (sawDependency(Filename, FromModule, IsSystem, IsModuleFile, IsMissing))
140     addDependency(Filename);
141 }
142 
143 bool DependencyCollector::addDependency(StringRef Filename) {
144   if (Seen.insert(Filename).second) {
145     Dependencies.push_back(std::string(Filename));
146     return true;
147   }
148   return false;
149 }
150 
151 static bool isSpecialFilename(StringRef Filename) {
152   return llvm::StringSwitch<bool>(Filename)
153       .Case("<built-in>", true)
154       .Case("<stdin>", true)
155       .Default(false);
156 }
157 
158 bool DependencyCollector::sawDependency(StringRef Filename, bool FromModule,
159                                         bool IsSystem, bool IsModuleFile,
160                                         bool IsMissing) {
161   return !isSpecialFilename(Filename) &&
162          (needSystemDependencies() || !IsSystem);
163 }
164 
165 DependencyCollector::~DependencyCollector() { }
166 void DependencyCollector::attachToPreprocessor(Preprocessor &PP) {
167   PP.addPPCallbacks(std::make_unique<DepCollectorPPCallbacks>(
168       *this, PP.getSourceManager(), PP.getDiagnostics()));
169   PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
170       std::make_unique<DepCollectorMMCallbacks>(*this));
171 }
172 void DependencyCollector::attachToASTReader(ASTReader &R) {
173   R.addListener(std::make_unique<DepCollectorASTListener>(*this));
174 }
175 
176 DependencyFileGenerator::DependencyFileGenerator(
177     const DependencyOutputOptions &Opts)
178     : OutputFile(Opts.OutputFile), Targets(Opts.Targets),
179       IncludeSystemHeaders(Opts.IncludeSystemHeaders),
180       PhonyTarget(Opts.UsePhonyTargets),
181       AddMissingHeaderDeps(Opts.AddMissingHeaderDeps), SeenMissingHeader(false),
182       IncludeModuleFiles(Opts.IncludeModuleFiles),
183       OutputFormat(Opts.OutputFormat), InputFileIndex(0) {
184   for (const auto &ExtraDep : Opts.ExtraDeps) {
185     if (addDependency(ExtraDep))
186       ++InputFileIndex;
187   }
188 }
189 
190 void DependencyFileGenerator::attachToPreprocessor(Preprocessor &PP) {
191   // Disable the "file not found" diagnostic if the -MG option was given.
192   if (AddMissingHeaderDeps)
193     PP.SetSuppressIncludeNotFoundError(true);
194 
195   DependencyCollector::attachToPreprocessor(PP);
196 }
197 
198 bool DependencyFileGenerator::sawDependency(StringRef Filename, bool FromModule,
199                                             bool IsSystem, bool IsModuleFile,
200                                             bool IsMissing) {
201   if (IsMissing) {
202     // Handle the case of missing file from an inclusion directive.
203     if (AddMissingHeaderDeps)
204       return true;
205     SeenMissingHeader = true;
206     return false;
207   }
208   if (IsModuleFile && !IncludeModuleFiles)
209     return false;
210 
211   if (isSpecialFilename(Filename))
212     return false;
213 
214   if (IncludeSystemHeaders)
215     return true;
216 
217   return !IsSystem;
218 }
219 
220 void DependencyFileGenerator::finishedMainFile(DiagnosticsEngine &Diags) {
221   outputDependencyFile(Diags);
222 }
223 
224 /// Print the filename, with escaping or quoting that accommodates the three
225 /// most likely tools that use dependency files: GNU Make, BSD Make, and
226 /// NMake/Jom.
227 ///
228 /// BSD Make is the simplest case: It does no escaping at all.  This means
229 /// characters that are normally delimiters, i.e. space and # (the comment
230 /// character) simply aren't supported in filenames.
231 ///
232 /// GNU Make does allow space and # in filenames, but to avoid being treated
233 /// as a delimiter or comment, these must be escaped with a backslash. Because
234 /// backslash is itself the escape character, if a backslash appears in a
235 /// filename, it should be escaped as well.  (As a special case, $ is escaped
236 /// as $$, which is the normal Make way to handle the $ character.)
237 /// For compatibility with BSD Make and historical practice, if GNU Make
238 /// un-escapes characters in a filename but doesn't find a match, it will
239 /// retry with the unmodified original string.
240 ///
241 /// GCC tries to accommodate both Make formats by escaping any space or #
242 /// characters in the original filename, but not escaping backslashes.  The
243 /// apparent intent is so that filenames with backslashes will be handled
244 /// correctly by BSD Make, and by GNU Make in its fallback mode of using the
245 /// unmodified original string; filenames with # or space characters aren't
246 /// supported by BSD Make at all, but will be handled correctly by GNU Make
247 /// due to the escaping.
248 ///
249 /// A corner case that GCC gets only partly right is when the original filename
250 /// has a backslash immediately followed by space or #.  GNU Make would expect
251 /// this backslash to be escaped; however GCC escapes the original backslash
252 /// only when followed by space, not #.  It will therefore take a dependency
253 /// from a directive such as
254 ///     #include "a\ b\#c.h"
255 /// and emit it as
256 ///     a\\\ b\\#c.h
257 /// which GNU Make will interpret as
258 ///     a\ b\
259 /// followed by a comment. Failing to find this file, it will fall back to the
260 /// original string, which probably doesn't exist either; in any case it won't
261 /// find
262 ///     a\ b\#c.h
263 /// which is the actual filename specified by the include directive.
264 ///
265 /// Clang does what GCC does, rather than what GNU Make expects.
266 ///
267 /// NMake/Jom has a different set of scary characters, but wraps filespecs in
268 /// double-quotes to avoid misinterpreting them; see
269 /// https://msdn.microsoft.com/en-us/library/dd9y37ha.aspx for NMake info,
270 /// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
271 /// for Windows file-naming info.
272 static void PrintFilename(raw_ostream &OS, StringRef Filename,
273                           DependencyOutputFormat OutputFormat) {
274   // Convert filename to platform native path
275   llvm::SmallString<256> NativePath;
276   llvm::sys::path::native(Filename.str(), NativePath);
277 
278   if (OutputFormat == DependencyOutputFormat::NMake) {
279     // Add quotes if needed. These are the characters listed as "special" to
280     // NMake, that are legal in a Windows filespec, and that could cause
281     // misinterpretation of the dependency string.
282     if (NativePath.find_first_of(" #${}^!") != StringRef::npos)
283       OS << '\"' << NativePath << '\"';
284     else
285       OS << NativePath;
286     return;
287   }
288   assert(OutputFormat == DependencyOutputFormat::Make);
289   for (unsigned i = 0, e = NativePath.size(); i != e; ++i) {
290     if (NativePath[i] == '#') // Handle '#' the broken gcc way.
291       OS << '\\';
292     else if (NativePath[i] == ' ') { // Handle space correctly.
293       OS << '\\';
294       unsigned j = i;
295       while (j > 0 && NativePath[--j] == '\\')
296         OS << '\\';
297     } else if (NativePath[i] == '$') // $ is escaped by $$.
298       OS << '$';
299     OS << NativePath[i];
300   }
301 }
302 
303 void DependencyFileGenerator::outputDependencyFile(DiagnosticsEngine &Diags) {
304   if (SeenMissingHeader) {
305     llvm::sys::fs::remove(OutputFile);
306     return;
307   }
308 
309   std::error_code EC;
310   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);
311   if (EC) {
312     Diags.Report(diag::err_fe_error_opening) << OutputFile << EC.message();
313     return;
314   }
315 
316   outputDependencyFile(OS);
317 }
318 
319 void DependencyFileGenerator::outputDependencyFile(llvm::raw_ostream &OS) {
320   // Write out the dependency targets, trying to avoid overly long
321   // lines when possible. We try our best to emit exactly the same
322   // dependency file as GCC (4.2), assuming the included files are the
323   // same.
324   const unsigned MaxColumns = 75;
325   unsigned Columns = 0;
326 
327   for (StringRef Target : Targets) {
328     unsigned N = Target.size();
329     if (Columns == 0) {
330       Columns += N;
331     } else if (Columns + N + 2 > MaxColumns) {
332       Columns = N + 2;
333       OS << " \\\n  ";
334     } else {
335       Columns += N + 1;
336       OS << ' ';
337     }
338     // Targets already quoted as needed.
339     OS << Target;
340   }
341 
342   OS << ':';
343   Columns += 1;
344 
345   // Now add each dependency in the order it was seen, but avoiding
346   // duplicates.
347   ArrayRef<std::string> Files = getDependencies();
348   for (StringRef File : Files) {
349     // Start a new line if this would exceed the column limit. Make
350     // sure to leave space for a trailing " \" in case we need to
351     // break the line on the next iteration.
352     unsigned N = File.size();
353     if (Columns + (N + 1) + 2 > MaxColumns) {
354       OS << " \\\n ";
355       Columns = 2;
356     }
357     OS << ' ';
358     PrintFilename(OS, File, OutputFormat);
359     Columns += N + 1;
360   }
361   OS << '\n';
362 
363   // Create phony targets if requested.
364   if (PhonyTarget && !Files.empty()) {
365     unsigned Index = 0;
366     for (auto I = Files.begin(), E = Files.end(); I != E; ++I) {
367       if (Index++ == InputFileIndex)
368         continue;
369       OS << '\n';
370       PrintFilename(OS, *I, OutputFormat);
371       OS << ":\n";
372     }
373   }
374 }
375