contrib/llvm/tools/clang/lib/Frontend/DependencyFile.cpp

   1 //===--- DependencyFile.cpp - Generate dependency file --------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This code generates dependency files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Frontend/Utils.h"
  15 #include "clang/Basic/FileManager.h"
  16 #include "clang/Basic/SourceManager.h"
  17 #include "clang/Frontend/DependencyOutputOptions.h"
  18 #include "clang/Frontend/FrontendDiagnostic.h"
  19 #include "clang/Lex/DirectoryLookup.h"
  20 #include "clang/Lex/ModuleMap.h"
  21 #include "clang/Lex/PPCallbacks.h"
  22 #include "clang/Lex/Preprocessor.h"
  23 #include "clang/Serialization/ASTReader.h"
  24 #include "llvm/ADT/StringSet.h"
  25 #include "llvm/ADT/StringSwitch.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/Path.h"
  28 #include "llvm/Support/raw_ostream.h"
  29
  30 using namespace clang;
  31
  32 namespace {
  33 struct DepCollectorPPCallbacks : public PPCallbacks {
  34   DependencyCollector &DepCollector;
  35   SourceManager &SM;
  36   DepCollectorPPCallbacks(DependencyCollector &L, SourceManager &SM)
  37       : DepCollector(L), SM(SM) { }
  38
  39   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
  40                    SrcMgr::CharacteristicKind FileType,
  41                    FileID PrevFID) override {
  42     if (Reason != PPCallbacks::EnterFile)
  43       return;
  44
  45     // Dependency generation really does want to go all the way to the
  46     // file entry for a source location to find out what is depended on.
  47     // We do not want #line markers to affect dependency generation!
  48     const FileEntry *FE =
  49         SM.getFileEntryForID(SM.getFileID(SM.getExpansionLoc(Loc)));
  50     if (!FE)
  51       return;
  52
  53     StringRef Filename =
  54         llvm::sys::path::remove_leading_dotslash(FE->getName());
  55
  56     DepCollector.maybeAddDependency(Filename, /*FromModule*/false,
  57                                     isSystem(FileType),
  58                                     /*IsModuleFile*/false, /*IsMissing*/false);
  59   }
  60
  61   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
  62                           StringRef FileName, bool IsAngled,
  63                           CharSourceRange FilenameRange, const FileEntry *File,
  64                           StringRef SearchPath, StringRef RelativePath,
  65                           const Module *Imported,
  66                           SrcMgr::CharacteristicKind FileType) override {
  67     if (!File)
  68       DepCollector.maybeAddDependency(FileName, /*FromModule*/false,
  69                                      /*IsSystem*/false, /*IsModuleFile*/false,
  70                                      /*IsMissing*/true);
  71     // Files that actually exist are handled by FileChanged.
  72   }
  73
  74   void EndOfMainFile() override {
  75     DepCollector.finishedMainFile();
  76   }
  77 };
  78
  79 struct DepCollectorMMCallbacks : public ModuleMapCallbacks {
  80   DependencyCollector &DepCollector;
  81   DepCollectorMMCallbacks(DependencyCollector &DC) : DepCollector(DC) {}
  82
  83   void moduleMapFileRead(SourceLocation Loc, const FileEntry &Entry,
  84                          bool IsSystem) override {
  85     StringRef Filename = Entry.getName();
  86     DepCollector.maybeAddDependency(Filename, /*FromModule*/false,
  87                                     /*IsSystem*/IsSystem,
  88                                     /*IsModuleFile*/false,
  89                                     /*IsMissing*/false);
  90   }
  91 };
  92
  93 struct DepCollectorASTListener : public ASTReaderListener {
  94   DependencyCollector &DepCollector;
  95   DepCollectorASTListener(DependencyCollector &L) : DepCollector(L) { }
  96   bool needsInputFileVisitation() override { return true; }
  97   bool needsSystemInputFileVisitation() override {
  98     return DepCollector.needSystemDependencies();
  99   }
 100   void visitModuleFile(StringRef Filename,
 101                        serialization::ModuleKind Kind) override {
 102     DepCollector.maybeAddDependency(Filename, /*FromModule*/true,
 103                                    /*IsSystem*/false, /*IsModuleFile*/true,
 104                                    /*IsMissing*/false);
 105   }
 106   bool visitInputFile(StringRef Filename, bool IsSystem,
 107                       bool IsOverridden, bool IsExplicitModule) override {
 108     if (IsOverridden || IsExplicitModule)
 109       return true;
 110
 111     DepCollector.maybeAddDependency(Filename, /*FromModule*/true, IsSystem,
 112                                    /*IsModuleFile*/false, /*IsMissing*/false);
 113     return true;
 114   }
 115 };
 116 } // end anonymous namespace
 117
 118 void DependencyCollector::maybeAddDependency(StringRef Filename, bool FromModule,
 119                                             bool IsSystem, bool IsModuleFile,
 120                                             bool IsMissing) {
 121   if (Seen.insert(Filename).second &&
 122       sawDependency(Filename, FromModule, IsSystem, IsModuleFile, IsMissing))
 123     Dependencies.push_back(Filename);
 124 }
 125
 126 static bool isSpecialFilename(StringRef Filename) {
 127   return llvm::StringSwitch<bool>(Filename)
 128       .Case("<built-in>", true)
 129       .Case("<stdin>", true)
 130       .Default(false);
 131 }
 132
 133 bool DependencyCollector::sawDependency(StringRef Filename, bool FromModule,
 134                                        bool IsSystem, bool IsModuleFile,
 135                                        bool IsMissing) {
 136   return !isSpecialFilename(Filename) &&
 137          (needSystemDependencies() || !IsSystem);
 138 }
 139
 140 DependencyCollector::~DependencyCollector() { }
 141 void DependencyCollector::attachToPreprocessor(Preprocessor &PP) {
 142   PP.addPPCallbacks(
 143       llvm::make_unique<DepCollectorPPCallbacks>(*this, PP.getSourceManager()));
 144   PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
 145       llvm::make_unique<DepCollectorMMCallbacks>(*this));
 146 }
 147 void DependencyCollector::attachToASTReader(ASTReader &R) {
 148   R.addListener(llvm::make_unique<DepCollectorASTListener>(*this));
 149 }
 150
 151 namespace {
 152 /// Private implementation for DependencyFileGenerator
 153 class DFGImpl : public PPCallbacks {
 154   std::vector<std::string> Files;
 155   llvm::StringSet<> FilesSet;
 156   const Preprocessor *PP;
 157   std::string OutputFile;
 158   std::vector<std::string> Targets;
 159   bool IncludeSystemHeaders;
 160   bool PhonyTarget;
 161   bool AddMissingHeaderDeps;
 162   bool SeenMissingHeader;
 163   bool IncludeModuleFiles;
 164   DependencyOutputFormat OutputFormat;
 165   unsigned InputFileIndex;
 166
 167 private:
 168   bool FileMatchesDepCriteria(const char *Filename,
 169                               SrcMgr::CharacteristicKind FileType);
 170   void OutputDependencyFile();
 171
 172 public:
 173   DFGImpl(const Preprocessor *_PP, const DependencyOutputOptions &Opts)
 174     : PP(_PP), OutputFile(Opts.OutputFile), Targets(Opts.Targets),
 175       IncludeSystemHeaders(Opts.IncludeSystemHeaders),
 176       PhonyTarget(Opts.UsePhonyTargets),
 177       AddMissingHeaderDeps(Opts.AddMissingHeaderDeps),
 178       SeenMissingHeader(false),
 179       IncludeModuleFiles(Opts.IncludeModuleFiles),
 180       OutputFormat(Opts.OutputFormat),
 181       InputFileIndex(0) {
 182     for (const auto &ExtraDep : Opts.ExtraDeps) {
 183       if (AddFilename(ExtraDep))
 184         ++InputFileIndex;
 185     }
 186   }
 187
 188   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
 189                    SrcMgr::CharacteristicKind FileType,
 190                    FileID PrevFID) override;
 191
 192   void FileSkipped(const FileEntry &SkippedFile, const Token &FilenameTok,
 193                    SrcMgr::CharacteristicKind FileType) override;
 194
 195   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
 196                           StringRef FileName, bool IsAngled,
 197                           CharSourceRange FilenameRange, const FileEntry *File,
 198                           StringRef SearchPath, StringRef RelativePath,
 199                           const Module *Imported,
 200                           SrcMgr::CharacteristicKind FileType) override;
 201
 202   void HasInclude(SourceLocation Loc, StringRef SpelledFilename, bool IsAngled,
 203                   const FileEntry *File,
 204                   SrcMgr::CharacteristicKind FileType) override;
 205
 206   void EndOfMainFile() override {
 207     OutputDependencyFile();
 208   }
 209
 210   bool AddFilename(StringRef Filename);
 211   bool includeSystemHeaders() const { return IncludeSystemHeaders; }
 212   bool includeModuleFiles() const { return IncludeModuleFiles; }
 213 };
 214
 215 class DFGMMCallback : public ModuleMapCallbacks {
 216   DFGImpl &Parent;
 217 public:
 218   DFGMMCallback(DFGImpl &Parent) : Parent(Parent) {}
 219   void moduleMapFileRead(SourceLocation Loc, const FileEntry &Entry,
 220                          bool IsSystem) override {
 221     if (!IsSystem || Parent.includeSystemHeaders())
 222       Parent.AddFilename(Entry.getName());
 223   }
 224 };
 225
 226 class DFGASTReaderListener : public ASTReaderListener {
 227   DFGImpl &Parent;
 228 public:
 229   DFGASTReaderListener(DFGImpl &Parent)
 230   : Parent(Parent) { }
 231   bool needsInputFileVisitation() override { return true; }
 232   bool needsSystemInputFileVisitation() override {
 233     return Parent.includeSystemHeaders();
 234   }
 235   void visitModuleFile(StringRef Filename,
 236                        serialization::ModuleKind Kind) override;
 237   bool visitInputFile(StringRef Filename, bool isSystem,
 238                       bool isOverridden, bool isExplicitModule) override;
 239 };
 240 }
 241
 242 DependencyFileGenerator::DependencyFileGenerator(void *Impl)
 243 : Impl(Impl) { }
 244
 245 DependencyFileGenerator *DependencyFileGenerator::CreateAndAttachToPreprocessor(
 246     clang::Preprocessor &PP, const clang::DependencyOutputOptions &Opts) {
 247
 248   if (Opts.Targets.empty()) {
 249     PP.getDiagnostics().Report(diag::err_fe_dependency_file_requires_MT);
 250     return nullptr;
 251   }
 252
 253   // Disable the "file not found" diagnostic if the -MG option was given.
 254   if (Opts.AddMissingHeaderDeps)
 255     PP.SetSuppressIncludeNotFoundError(true);
 256
 257   DFGImpl *Callback = new DFGImpl(&PP, Opts);
 258   PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callback));
 259   PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
 260       llvm::make_unique<DFGMMCallback>(*Callback));
 261   return new DependencyFileGenerator(Callback);
 262 }
 263
 264 void DependencyFileGenerator::AttachToASTReader(ASTReader &R) {
 265   DFGImpl *I = reinterpret_cast<DFGImpl *>(Impl);
 266   assert(I && "missing implementation");
 267   R.addListener(llvm::make_unique<DFGASTReaderListener>(*I));
 268 }
 269
 270 /// FileMatchesDepCriteria - Determine whether the given Filename should be
 271 /// considered as a dependency.
 272 bool DFGImpl::FileMatchesDepCriteria(const char *Filename,
 273                                      SrcMgr::CharacteristicKind FileType) {
 274   if (isSpecialFilename(Filename))
 275     return false;
 276
 277   if (IncludeSystemHeaders)
 278     return true;
 279
 280   return !isSystem(FileType);
 281 }
 282
 283 void DFGImpl::FileChanged(SourceLocation Loc,
 284                           FileChangeReason Reason,
 285                           SrcMgr::CharacteristicKind FileType,
 286                           FileID PrevFID) {
 287   if (Reason != PPCallbacks::EnterFile)
 288     return;
 289
 290   // Dependency generation really does want to go all the way to the
 291   // file entry for a source location to find out what is depended on.
 292   // We do not want #line markers to affect dependency generation!
 293   SourceManager &SM = PP->getSourceManager();
 294
 295   const FileEntry *FE =
 296     SM.getFileEntryForID(SM.getFileID(SM.getExpansionLoc(Loc)));
 297   if (!FE) return;
 298
 299   StringRef Filename = FE->getName();
 300   if (!FileMatchesDepCriteria(Filename.data(), FileType))
 301     return;
 302
 303   AddFilename(llvm::sys::path::remove_leading_dotslash(Filename));
 304 }
 305
 306 void DFGImpl::FileSkipped(const FileEntry &SkippedFile,
 307                           const Token &FilenameTok,
 308                           SrcMgr::CharacteristicKind FileType) {
 309   StringRef Filename = SkippedFile.getName();
 310   if (!FileMatchesDepCriteria(Filename.data(), FileType))
 311     return;
 312
 313   AddFilename(llvm::sys::path::remove_leading_dotslash(Filename));
 314 }
 315
 316 void DFGImpl::InclusionDirective(SourceLocation HashLoc,
 317                                  const Token &IncludeTok,
 318                                  StringRef FileName,
 319                                  bool IsAngled,
 320                                  CharSourceRange FilenameRange,
 321                                  const FileEntry *File,
 322                                  StringRef SearchPath,
 323                                  StringRef RelativePath,
 324                                  const Module *Imported,
 325                                  SrcMgr::CharacteristicKind FileType) {
 326   if (!File) {
 327     if (AddMissingHeaderDeps)
 328       AddFilename(FileName);
 329     else
 330       SeenMissingHeader = true;
 331   }
 332 }
 333
 334 void DFGImpl::HasInclude(SourceLocation Loc, StringRef SpelledFilename,
 335                          bool IsAngled, const FileEntry *File,
 336                          SrcMgr::CharacteristicKind FileType) {
 337   if (!File)
 338     return;
 339   StringRef Filename = File->getName();
 340   if (!FileMatchesDepCriteria(Filename.data(), FileType))
 341     return;
 342   AddFilename(llvm::sys::path::remove_leading_dotslash(Filename));
 343 }
 344
 345 bool DFGImpl::AddFilename(StringRef Filename) {
 346   if (FilesSet.insert(Filename).second) {
 347     Files.push_back(Filename);
 348     return true;
 349   }
 350   return false;
 351 }
 352
 353 /// Print the filename, with escaping or quoting that accommodates the three
 354 /// most likely tools that use dependency files: GNU Make, BSD Make, and
 355 /// NMake/Jom.
 356 ///
 357 /// BSD Make is the simplest case: It does no escaping at all.  This means
 358 /// characters that are normally delimiters, i.e. space and # (the comment
 359 /// character) simply aren't supported in filenames.
 360 ///
 361 /// GNU Make does allow space and # in filenames, but to avoid being treated
 362 /// as a delimiter or comment, these must be escaped with a backslash. Because
 363 /// backslash is itself the escape character, if a backslash appears in a
 364 /// filename, it should be escaped as well.  (As a special case, $ is escaped
 365 /// as $$, which is the normal Make way to handle the $ character.)
 366 /// For compatibility with BSD Make and historical practice, if GNU Make
 367 /// un-escapes characters in a filename but doesn't find a match, it will
 368 /// retry with the unmodified original string.
 369 ///
 370 /// GCC tries to accommodate both Make formats by escaping any space or #
 371 /// characters in the original filename, but not escaping backslashes.  The
 372 /// apparent intent is so that filenames with backslashes will be handled
 373 /// correctly by BSD Make, and by GNU Make in its fallback mode of using the
 374 /// unmodified original string; filenames with # or space characters aren't
 375 /// supported by BSD Make at all, but will be handled correctly by GNU Make
 376 /// due to the escaping.
 377 ///
 378 /// A corner case that GCC gets only partly right is when the original filename
 379 /// has a backslash immediately followed by space or #.  GNU Make would expect
 380 /// this backslash to be escaped; however GCC escapes the original backslash
 381 /// only when followed by space, not #.  It will therefore take a dependency
 382 /// from a directive such as
 383 ///     #include "a\ b\#c.h"
 384 /// and emit it as
 385 ///     a\\\ b\\#c.h
 386 /// which GNU Make will interpret as
 387 ///     a\ b\
 388 /// followed by a comment. Failing to find this file, it will fall back to the
 389 /// original string, which probably doesn't exist either; in any case it won't
 390 /// find
 391 ///     a\ b\#c.h
 392 /// which is the actual filename specified by the include directive.
 393 ///
 394 /// Clang does what GCC does, rather than what GNU Make expects.
 395 ///
 396 /// NMake/Jom has a different set of scary characters, but wraps filespecs in
 397 /// double-quotes to avoid misinterpreting them; see
 398 /// https://msdn.microsoft.com/en-us/library/dd9y37ha.aspx for NMake info,
 399 /// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
 400 /// for Windows file-naming info.
 401 static void PrintFilename(raw_ostream &OS, StringRef Filename,
 402                           DependencyOutputFormat OutputFormat) {
 403   // Convert filename to platform native path
 404   llvm::SmallString<256> NativePath;
 405   llvm::sys::path::native(Filename.str(), NativePath);
 406
 407   if (OutputFormat == DependencyOutputFormat::NMake) {
 408     // Add quotes if needed. These are the characters listed as "special" to
 409     // NMake, that are legal in a Windows filespec, and that could cause
 410     // misinterpretation of the dependency string.
 411     if (NativePath.find_first_of(" #${}^!") != StringRef::npos)
 412       OS << '\"' << NativePath << '\"';
 413     else
 414       OS << NativePath;
 415     return;
 416   }
 417   assert(OutputFormat == DependencyOutputFormat::Make);
 418   for (unsigned i = 0, e = NativePath.size(); i != e; ++i) {
 419     if (NativePath[i] == '#') // Handle '#' the broken gcc way.
 420       OS << '\\';
 421     else if (NativePath[i] == ' ') { // Handle space correctly.
 422       OS << '\\';
 423       unsigned j = i;
 424       while (j > 0 && NativePath[--j] == '\\')
 425         OS << '\\';
 426     } else if (NativePath[i] == '$') // $ is escaped by $$.
 427       OS << '$';
 428     OS << NativePath[i];
 429   }
 430 }
 431
 432 void DFGImpl::OutputDependencyFile() {
 433   if (SeenMissingHeader) {
 434     llvm::sys::fs::remove(OutputFile);
 435     return;
 436   }
 437
 438   std::error_code EC;
 439   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::F_Text);
 440   if (EC) {
 441     PP->getDiagnostics().Report(diag::err_fe_error_opening) << OutputFile
 442                                                             << EC.message();
 443     return;
 444   }
 445
 446   // Write out the dependency targets, trying to avoid overly long
 447   // lines when possible. We try our best to emit exactly the same
 448   // dependency file as GCC (4.2), assuming the included files are the
 449   // same.
 450   const unsigned MaxColumns = 75;
 451   unsigned Columns = 0;
 452
 453   for (StringRef Target : Targets) {
 454     unsigned N = Target.size();
 455     if (Columns == 0) {
 456       Columns += N;
 457     } else if (Columns + N + 2 > MaxColumns) {
 458       Columns = N + 2;
 459       OS << " \\\n  ";
 460     } else {
 461       Columns += N + 1;
 462       OS << ' ';
 463     }
 464     // Targets already quoted as needed.
 465     OS << Target;
 466   }
 467
 468   OS << ':';
 469   Columns += 1;
 470
 471   // Now add each dependency in the order it was seen, but avoiding
 472   // duplicates.
 473   for (StringRef File : Files) {
 474     // Start a new line if this would exceed the column limit. Make
 475     // sure to leave space for a trailing " \" in case we need to
 476     // break the line on the next iteration.
 477     unsigned N = File.size();
 478     if (Columns + (N + 1) + 2 > MaxColumns) {
 479       OS << " \\\n ";
 480       Columns = 2;
 481     }
 482     OS << ' ';
 483     PrintFilename(OS, File, OutputFormat);
 484     Columns += N + 1;
 485   }
 486   OS << '\n';
 487
 488   // Create phony targets if requested.
 489   if (PhonyTarget && !Files.empty()) {
 490     unsigned Index = 0;
 491     for (auto I = Files.begin(), E = Files.end(); I != E; ++I) {
 492       if (Index++ == InputFileIndex)
 493         continue;
 494       OS << '\n';
 495       PrintFilename(OS, *I, OutputFormat);
 496       OS << ":\n";
 497     }
 498   }
 499 }
 500
 501 bool DFGASTReaderListener::visitInputFile(llvm::StringRef Filename,
 502                                           bool IsSystem, bool IsOverridden,
 503                                           bool IsExplicitModule) {
 504   assert(!IsSystem || needsSystemInputFileVisitation());
 505   if (IsOverridden || IsExplicitModule)
 506     return true;
 507
 508   Parent.AddFilename(Filename);
 509   return true;
 510 }
 511
 512 void DFGASTReaderListener::visitModuleFile(llvm::StringRef Filename,
 513                                            serialization::ModuleKind Kind) {
 514   if (Parent.includeModuleFiles())
 515     Parent.AddFilename(Filename);
 516 }