clang-cl: Include /FI headers in /showIncludes output.

[thakis]

Summary

-H in gcc mode doesn't print -include headers, but they are included in depfiles written by MMD and friends. Since /showIncludes is what's used instead of depfiles, printing /FI there seems important (and matches cl.exe).

There's more work to do for the interaction of /FI, /showIncludes, and PCH flags, but this is a strict improvement over what we have today.

Instead of giving HeaderIncludeGen more options, just switch on ShowAllHeaders in clang-cl mode and let clang::InitializePreprocessor() not put -include flags in the <command line> block. This changes the behavior of -E slightly, and it removes the <command line> flag from the output triggered by setting the obscure CC_PRINT_HEADERS=1 env var to true while running clang. Both of these seem ok to change.

[thakis]

On second thought, and after looking at -E output with -include and gch files, and at CC_PRINT_HEADERS behavior (it prints <command-line> but doesn't indent), I think I like the alternative implementation I'm mentioning better. Let me make that change.

[rsmith]

lib/Frontend/HeaderIncludeGen.cpp

165–168

Missing "if" or similar in this comment?

169

I'm not a fan of using strcmp like this (implicitly converting the result to bool to mean "check strings are different"). I'd prefer you used

UserLoc.getFilename() != StringRef("<command line>")

(Of course, ideally we'd use something more principled than a check against the filename string... please add a FIXME for that.)

[thakis]

Thanks! All done.

[thakis]

…and landed in r264174.

include/clang/Frontend/Utils.h

public:
   ~ModuleDependencyCollector() { writeFileMap(); }
 };
 
 /// AttachDependencyGraphGen - Create a dependency graph generator, and attach
 /// it to the given preprocessor.
   void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,
                                 StringRef SysRoot);
 
+enum IncludeGenShowHeadersKind {
+  // Don't print headers from the predefines buffer (i.e. from -include flags).
+  IGSHK_OmitPredefines,
+
+  // Print headers from the predefines buffer scoped under a "<command line>"
+  // item.
+  IGSHK_ScopePredefines,
+
+  // Print headers from the predefines buffer without scoping, as if they were
+  // included by the main translation unit.
+  IGSHK_InlinePredefines,
+};
+
 /// AttachHeaderIncludeGen - Create a header include list generator, and attach
 /// it to the given preprocessor.
 ///
 /// \param ExtraHeaders - If not empty, will write the header filenames, just
 /// like they were included during a regular preprocessing. Useful for
 /// implicit include dependencies, like sanitizer blacklists.
 /// \param ShowAllHeaders - If true, show all header information instead of just
 /// headers following the predefines buffer. This is useful for making sure
 /// includes mentioned on the command line are also reported, but differs from
 /// the default behavior used by -H.
 /// \param OutputPath - If non-empty, a path to write the header include
 /// information to, instead of writing to stderr.
 /// \param ShowDepth - Whether to indent to show the nesting of the includes.
 /// \param MSStyle - Whether to print in cl.exe /showIncludes style.
-void AttachHeaderIncludeGen(Preprocessor &PP,
-                            const std::vector<std::string> &ExtraHeaders,
-                            bool ShowAllHeaders = false,
-                            StringRef OutputPath = "",
-                            bool ShowDepth = true, bool MSStyle = false);
+void AttachHeaderIncludeGen(
+    Preprocessor &PP, const std::vector<std::string> &ExtraHeaders,
+    IncludeGenShowHeadersKind ShowAllHeaders = IGSHK_OmitPredefines,
+    StringRef OutputPath = "", bool ShowDepth = true, bool MSStyle = false);
 
 /// Cache tokens for use with PCH. Note that this requires a seekable stream.
 void CacheTokens(Preprocessor &PP, raw_pwrite_stream *OS);
 
 /// The ChainedIncludesSource class converts headers to chained PCHs in
 /// memory, mainly for testing.
 IntrusiveRefCntPtr<ExternalSemaSource>
 createChainedIncludesSource(CompilerInstance &CI,

lib/Frontend/CompilerInstance.cpp

void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
   // Handle generating header include information, if requested.
   if (DepOpts.ShowHeaderIncludes)
     AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps);
   if (!DepOpts.HeaderIncludeOutputFile.empty()) {
     StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
     if (OutputPath == "-")
       OutputPath = "";
     AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps,
-                           /*ShowAllHeaders=*/true, OutputPath,
+                           IGSHK_ScopePredefines, OutputPath,
                            /*ShowDepth=*/false);
   }
 
   if (DepOpts.PrintShowIncludes) {
     AttachHeaderIncludeGen(*PP, DepOpts.ExtraDeps,
-                           /*ShowAllHeaders=*/false, /*OutputPath=*/"",
+                           IGSHK_InlinePredefines, /*OutputPath=*/"",
                            /*ShowDepth=*/true, /*MSStyle=*/true);
   }
 }
 
 std::string CompilerInstance::getSpecificModuleCachePath() {
   // Set up the module path, including the hash for the
   // module-creation options.
   SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);

lib/Frontend/HeaderIncludeGen.cpp

 using namespace clang;
 
 namespace {
 class HeaderIncludesCallback : public PPCallbacks {
   SourceManager &SM;
   raw_ostream *OutputFile;
   const std::vector<std::string> &ExtraHeaders;
   unsigned CurrentIncludeDepth;
+  IncludeGenShowHeadersKind ShowAllHeaders;
   bool HasProcessedPredefines;
   bool OwnsOutputFile;
-  bool ShowAllHeaders;
   bool ShowDepth;
   bool MSStyle;
   bool PrintedExtraHeaders;
 
 public:
-  HeaderIncludesCallback(const Preprocessor *PP, bool ShowAllHeaders_,
+  HeaderIncludesCallback(const Preprocessor *PP,
+                         IncludeGenShowHeadersKind ShowAllHeaders_,
                          raw_ostream *OutputFile_,
                          const std::vector<std::string> &ExtraHeaders,
                          bool OwnsOutputFile_, bool ShowDepth_, bool MSStyle_)
       : SM(PP->getSourceManager()), OutputFile(OutputFile_),
         ExtraHeaders(ExtraHeaders), CurrentIncludeDepth(0),
-        HasProcessedPredefines(false), OwnsOutputFile(OwnsOutputFile_),
-        ShowAllHeaders(ShowAllHeaders_), ShowDepth(ShowDepth_),
+        ShowAllHeaders(ShowAllHeaders_), HasProcessedPredefines(false),
+        OwnsOutputFile(OwnsOutputFile_), ShowDepth(ShowDepth_),
         MSStyle(MSStyle_), PrintedExtraHeaders(false) {}
 
   ~HeaderIncludesCallback() override {
     if (OwnsOutputFile)
       delete OutputFile;
   }
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
static void PrintHeaderInfo(raw_ostream *OutputFile, const char* Filename,
     Msg += '\n';
 
     OutputFile->write(Msg.data(), Msg.size());
     OutputFile->flush();
 }
 
 void clang::AttachHeaderIncludeGen(Preprocessor &PP,
                                    const std::vector<std::string> &ExtraHeaders,
-                                   bool ShowAllHeaders,
+                                   IncludeGenShowHeadersKind ShowAllHeaders,
                                    StringRef OutputPath, bool ShowDepth,
                                    bool MSStyle) {
   raw_ostream *OutputFile = MSStyle ? &llvm::outs() : &llvm::errs();
   bool OwnsOutputFile = false;
 
   // Open the output file, if used.
   if (!OutputPath.empty()) {
     std::error_code EC;
if (Reason == PPCallbacks::EnterFile) {
 
     return;
   } else
     return;
 
   // Show the header if we are (a) past the predefines, or (b) showing all
   // headers and in the predefines at a depth past the initial file and command
   // line buffers.
-  bool ShowHeader = (HasProcessedPredefines ||
-                     (ShowAllHeaders && CurrentIncludeDepth > 2));
+  bool ShowHeader = false;
+  unsigned IncludeDepth = CurrentIncludeDepth;
+  if (HasProcessedPredefines)
+    ShowHeader = true;
+  else {
+    if (ShowAllHeaders == IGSHK_ScopePredefines && CurrentIncludeDepth > 2)
+      ShowHeader = true;
+    else if (ShowAllHeaders == IGSHK_InlinePredefines &&
+             CurrentIncludeDepth > 3) {
+      ShowHeader = true;
+      // Ignore indent relative to <built-in> and <command line>.
+      IncludeDepth -= 2;
+    } 
+  }
   
   // Dump the header include information we are past the predefines buffer or
   // are showing all headers.
   if (ShowHeader && Reason == PPCallbacks::EnterFile) {
-    PrintHeaderInfo(OutputFile, UserLoc.getFilename(),
-                    ShowDepth, CurrentIncludeDepth, MSStyle);
+    PrintHeaderInfo(OutputFile, UserLoc.getFilename(), ShowDepth, IncludeDepth,
+                    MSStyle);
   }
 }

test/Driver/cl-pch-showincludes.cpp

 // Note: %s and %S must be preceded by --, otherwise it may be interpreted as a
 // command-line option, e.g. on Mac where %s is commonly under /Users.
 
 // Tests interaction of /Yc / /Yu with /showIncludes
 // REQUIRES: x86-registered-target
 
 #include "header3.h"
 
 // When building the pch, header1.h (included by header2.h), header2.h (the pch
 // input itself) and header3.h (included directly, above) should be printed.
-// RUN: %clang_cl -Werror /showIncludes /I%S/Inputs /Ycheader2.h /FIheader2.h /Fp%t.pch /c /Fo%t -- %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=CHECK-YC %s
-// CHECK-YC: Note: including file: {{.+header2.h}}
-// CHECK-YC: Note: including file: {{.+header1.h}}
-// CHECK-YC: Note: including file: {{.+header3.h}}
+// RUN: %clang_cl -Werror /showIncludes /I%S/Inputs /Ycheader2.h /FIheader2.h /Fp%t.pch /c /Fo%t -- %s \
+// RUN:   | FileCheck --strict-whitespace -check-prefix=CHECK-YC %s
+// CHECK-YC: Note: including file: {{[^ ]*header2.h}}
+// FIXME: header1.h should be indented one more:
+// CHECK-YC: Note: including file: {{[^ ]*header1.h}}
+// CHECK-YC: Note: including file: {{[^ ]*header3.h}}
 
 // When using the pch, only the direct include is printed.
-// RUN: %clang_cl -Werror /showIncludes /I%S/Inputs /Yuheader2.h /FIheader2.h /Fp%t.pch /c /Fo%t -- %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=CHECK-YU %s
+// RUN: %clang_cl -Werror /showIncludes /I%S/Inputs /Yuheader2.h /FIheader2.h /Fp%t.pch /c /Fo%t -- %s \
+// RUN:   | FileCheck --strict-whitespace -check-prefix=CHECK-YU %s
 // CHECK-YU-NOT: Note: including file: {{.*pch}}
 // CHECK-YU-NOT: Note: including file: {{.*header1.h}}
 // CHECK-YU-NOT: Note: including file: {{.*header2.h}}
-// CHECK-YU: Note: including file: {{.+header3.h}}
+// CHECK-YU: Note: including file: {{[^ ]*header3.h}}

test/Frontend/print-header-includes.c

-// RUN: cd %S
-// RUN: %clang_cc1 -include Inputs/test3.h -E -H -o %t.out %s 2> %t.stderr
+// RUN: %clang_cc1 -I%S -include Inputs/test3.h -E -H -o /dev/null %s 2> %t.stderr
 // RUN: FileCheck < %t.stderr %s
 
 // CHECK-NOT: test3.h
 // CHECK: . {{.*test.h}}
 // CHECK: .. {{.*test2.h}}
 
-// RUN: %clang_cc1 -include Inputs/test3.h -E --show-includes -o %t.out %s > %t.stdout
-// RUN: FileCheck --check-prefix=MS < %t.stdout %s
-// MS-NOT: test3.h
-// MS: Note: including file: {{.*test.h}}
-// MS: Note: including file:  {{.*test2.h}}
+// RUN: %clang_cc1 -I%S -include Inputs/test3.h -E --show-includes -o /dev/null %s | \
+// RUN:     FileCheck --strict-whitespace --check-prefix=MS %s
+// MS-NOT: <command line>
+// MS: Note: including file: {{[^ ]*test3.h}}
+// MS: Note: including file: {{[^ ]*test.h}}
+// MS: Note: including file:  {{[^ ]*test2.h}}
 // MS-NOT: Note
 
 // RUN: echo "fun:foo" > %t.blacklist
-// RUN: %clang_cc1 -fsanitize=address -fdepfile-entry=%t.blacklist -E --show-includes -o %t.out %s > %t.stdout
-// RUN: FileCheck --check-prefix=MS-BLACKLIST < %t.stdout %s
-// MS-BLACKLIST: Note: including file: {{.*\.blacklist}}
-// MS-BLACKLIST: Note: including file: {{.*test.h}}
-// MS-BLACKLIST: Note: including file:  {{.*test2.h}}
+// RUN: %clang_cc1 -I%S -fsanitize=address -fdepfile-entry=%t.blacklist -E --show-includes -o /dev/null %s | \
+// RUN:     FileCheck --strict-whitespace --check-prefix=MS-BLACKLIST %s
+// MS-BLACKLIST: Note: including file: {{[^ ]*\.blacklist}}
+// MS-BLACKLIST: Note: including file: {{[^ ]*test.h}}
+// MS-BLACKLIST: Note: including file:  {{[^ ]*test2.h}}
 // MS-BLACKLIST-NOT: Note
 
 #include "Inputs/test.h"