1 files changed, 164 insertions, 33 deletions

diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 3776fec..ee47e46 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -12,7 +12,9 @@
 #include <utility>
 
 #include <cm/memory>
+#include <cm/string_view>
 #include <cmext/algorithm>
+#include <cmext/string_view>
 
 #include "cmComputeLinkInformation.h"
 #include "cmCustomCommand.h"
@@ -23,6 +25,7 @@
 #include "cmGlobalUnixMakefileGenerator3.h"
 #include "cmLinkLineComputer.h" // IWYU pragma: keep
 #include "cmLocalCommonGenerator.h"
+#include "cmLocalGenerator.h"
 #include "cmLocalUnixMakefileGenerator3.h"
 #include "cmMakefile.h"
 #include "cmMakefileExecutableTargetGenerator.h"
@@ -325,7 +328,45 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
     << cmSystemTools::ConvertToOutputPath(
          this->LocalGenerator->MaybeConvertToRelativePath(
            this->LocalGenerator->GetBinaryDirectory(), dependFileNameFull))
-    << "\n\n";
+    << "\n";
+
+  std::string depsUseCompiler = "CMAKE_DEPENDS_USE_COMPILER";
+  if (!this->Makefile->IsDefinitionSet(depsUseCompiler) ||
+      this->Makefile->IsOn(depsUseCompiler)) {
+    std::string compilerDependFile =
+      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.make");
+    *this->BuildFileStream
+      << "# Include any dependencies generated by the "
+         "compiler for this target.\n"
+      << this->GlobalGenerator->IncludeDirective << " " << root
+      << cmSystemTools::ConvertToOutputPath(
+           this->LocalGenerator->MaybeConvertToRelativePath(
+             this->LocalGenerator->GetBinaryDirectory(), compilerDependFile))
+      << "\n\n";
+
+    if (!cmSystemTools::FileExists(compilerDependFile)) {
+      // Write an empty dependency file.
+      cmGeneratedFileStream depFileStream(
+        compilerDependFile, false,
+        this->GlobalGenerator->GetMakefileEncoding());
+      depFileStream << "# Empty compiler generated dependencies file for "
+                    << this->GeneratorTarget->GetName() << ".\n"
+                    << "# This may be replaced when dependencies are built.\n";
+    }
+
+    std::string compilerDependTimestamp =
+      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.ts");
+    if (!cmSystemTools::FileExists(compilerDependTimestamp)) {
+      // Write a dependency timestamp file.
+      cmGeneratedFileStream depFileStream(
+        compilerDependTimestamp, false,
+        this->GlobalGenerator->GetMakefileEncoding());
+      depFileStream << "# CMAKE generated file: DO NOT EDIT!\n"
+                    << "# Timestamp file for compiler generated dependencies "
+                       "management for "
+                    << this->GeneratorTarget->GetName() << ".\n";
+    }
+  }
 
   if (!this->NoRuleMessages) {
     // Include the progress variables for the target.
@@ -472,6 +513,14 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
     return;
   }
 
+  // Use compiler to generate dependencies, if supported.
+  bool compilerGenerateDeps =
+    this->GlobalGenerator->SupportsCompilerDependencies() &&
+    cmIsOn(this->Makefile->GetDefinition(
+      cmStrCat("CMAKE_", lang, "_DEPENDS_USE_COMPILER")));
+  auto scanner = compilerGenerateDeps ? cmDependencyScannerKind::Compiler
+                                      : cmDependencyScannerKind::CMake;
+
   // Get the full path name of the object file.
   std::string const& objectName =
     this->GeneratorTarget->GetObjectName(&source);
@@ -511,7 +560,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
   std::string srcFullPath =
     cmSystemTools::CollapseFullPath(source.GetFullPath());
   this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, lang,
-                                           objFullPath, srcFullPath);
+                                           objFullPath, srcFullPath, scanner);
 
   this->LocalGenerator->AppendRuleDepend(depends,
                                          this->FlagFileNameFull.c_str());
@@ -553,8 +602,8 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
         depends.push_back(
           this->GeneratorTarget->GetPchFile(config, lang, arch));
       }
-      this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, lang,
-                                               objFullPath, pchHeader);
+      this->LocalGenerator->AddImplicitDepends(
+        this->GeneratorTarget, lang, objFullPath, pchHeader, scanner);
     }
   }
 
@@ -573,6 +622,10 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
   // Build the set of compiler flags.
   std::string flags;
 
+  // Explicitly add the explicit language flag before any other flag
+  // so user flags can override it.
+  this->GeneratorTarget->AddExplicitLanguageFlags(flags, source);
+
   // Add language-specific flags.
   std::string langFlags = cmStrCat("$(", lang, "_FLAGS", filterArch, ")");
   this->LocalGenerator->AppendFlags(flags, langFlags);
@@ -688,7 +741,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
     source.GetFullPath(), cmOutputConverter::SHELL);
 
   // Construct the build message.
-  std::vector<std::string> no_commands;
+  std::vector<std::string> no_depends;
   std::vector<std::string> commands;
 
   // add in a progress call if needed
@@ -782,13 +835,33 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
                                     "$(" + lang + "_INCLUDES)");
   vars.Includes = includesString.c_str();
 
+  std::string dependencyTarget;
+  std::string shellDependencyFile;
+  std::string dependencyTimestamp;
+  if (compilerGenerateDeps) {
+    dependencyTarget = this->LocalGenerator->EscapeForShell(
+      this->LocalGenerator->ConvertToMakefilePath(
+        this->LocalGenerator->MaybeConvertToRelativePath(
+          this->LocalGenerator->GetBinaryDirectory(), relativeObj)));
+    vars.DependencyTarget = dependencyTarget.c_str();
+
+    auto depFile = cmStrCat(obj, ".d");
+    shellDependencyFile = this->LocalGenerator->ConvertToOutputFormat(
+      depFile, cmOutputConverter::SHELL);
+    vars.DependencyFile = shellDependencyFile.c_str();
+
+    dependencyTimestamp = this->LocalGenerator->MaybeConvertToRelativePath(
+      this->LocalGenerator->GetBinaryDirectory(),
+      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.ts"));
+  }
+
   // At the moment, it is assumed that C, C++, Fortran, and CUDA have both
   // assembly and preprocessor capabilities. The same is true for the
   // ability to export compile commands
   bool lang_has_preprocessor =
     ((lang == "C") || (lang == "CXX") || (lang == "OBJC") ||
      (lang == "OBJCXX") || (lang == "Fortran") || (lang == "CUDA") ||
-     lang == "ISPC");
+     lang == "ISPC" || lang == "ASM");
   bool const lang_has_assembly = lang_has_preprocessor;
   bool const lang_can_export_cmds = lang_has_preprocessor;
 
@@ -870,15 +943,21 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
     }
 
     // Maybe insert an include-what-you-use runner.
-    if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) {
-      std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
-      cmProp iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
+    if (!compileCommands.empty() &&
+        (lang == "C" || lang == "CXX" || lang == "OBJC" || lang == "OBJCXX")) {
       std::string const tidy_prop = lang + "_CLANG_TIDY";
       cmProp tidy = this->GeneratorTarget->GetProperty(tidy_prop);
-      std::string const cpplint_prop = lang + "_CPPLINT";
-      cmProp cpplint = this->GeneratorTarget->GetProperty(cpplint_prop);
-      std::string const cppcheck_prop = lang + "_CPPCHECK";
-      cmProp cppcheck = this->GeneratorTarget->GetProperty(cppcheck_prop);
+      cmProp iwyu = nullptr;
+      cmProp cpplint = nullptr;
+      cmProp cppcheck = nullptr;
+      if (lang == "C" || lang == "CXX") {
+        std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
+        iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
+        std::string const cpplint_prop = lang + "_CPPLINT";
+        cpplint = this->GeneratorTarget->GetProperty(cpplint_prop);
+        std::string const cppcheck_prop = lang + "_CPPCHECK";
+        cppcheck = this->GeneratorTarget->GetProperty(cppcheck_prop);
+      }
       if (cmNonempty(iwyu) || cmNonempty(tidy) || cmNonempty(cpplint) ||
           cmNonempty(cppcheck)) {
         std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_co_compile";
@@ -940,10 +1019,57 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
 
     std::string launcher;
     {
-      const char* val = this->LocalGenerator->GetRuleLauncher(
+      cmProp val = this->LocalGenerator->GetRuleLauncher(
         this->GeneratorTarget, "RULE_LAUNCH_COMPILE");
       if (cmNonempty(val)) {
-        launcher = cmStrCat(val, ' ');
+        launcher = cmStrCat(*val, ' ');
+      }
+    }
+
+    std::string flagsWithDeps(flags);
+
+    if (compilerGenerateDeps) {
+      // Injects dependency computation
+      auto depFlags = this->Makefile->GetSafeDefinition(
+        cmStrCat("CMAKE_DEPFILE_FLAGS_", lang));
+
+      if (!depFlags.empty()) {
+        // Add dependency flags
+        rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
+                                                     depFlags, vars);
+        flagsWithDeps.append(1, ' ');
+        flagsWithDeps.append(depFlags);
+      }
+      vars.Flags = flagsWithDeps.c_str();
+
+      const auto& extraCommands = this->Makefile->GetSafeDefinition(
+        cmStrCat("CMAKE_", lang, "_DEPENDS_EXTRA_COMMANDS"));
+      if (!extraCommands.empty()) {
+        auto commandList = cmExpandedList(extraCommands);
+        compileCommands.insert(compileCommands.end(), commandList.cbegin(),
+                               commandList.cend());
+      }
+
+      const auto& depFormat = this->Makefile->GetRequiredDefinition(
+        cmStrCat("CMAKE_", lang, "_DEPFILE_FORMAT"));
+
+      if (depFormat == "msvc"_s) {
+        // compiler must be launched through a wrapper to pick-up dependencies
+        std::string depFilter =
+          "$(CMAKE_COMMAND) -E cmake_cl_compile_depends ";
+        depFilter += cmStrCat("--dep-file=", shellDependencyFile);
+        depFilter +=
+          cmStrCat(" --working-dir=",
+                   this->LocalGenerator->ConvertToOutputFormat(
+                     this->LocalGenerator->GetCurrentBinaryDirectory(),
+                     cmOutputConverter::SHELL));
+        const auto& prefix = this->Makefile->GetSafeDefinition(
+          cmStrCat("CMAKE_", lang, "_CL_SHOWINCLUDES_PREFIX"));
+        depFilter += cmStrCat(" --filter-prefix=",
+                              this->LocalGenerator->ConvertToOutputFormat(
+                                prefix, cmOutputConverter::SHELL));
+        depFilter += " -- ";
+        compileCommands.front().insert(0, depFilter);
       }
     }
 
@@ -972,8 +1098,8 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
       cmExpandList(evaluated_outputs, outputs);
     }
   }
-  if (!ispcHeaderRelative
-         .empty()) { // can't move ispcHeader as vars is using it
+  if (!ispcHeaderRelative.empty()) {
+    // can't move ispcHeader as vars is using it
     outputs.emplace_back(ispcHeaderRelative);
   }
 
@@ -981,10 +1107,19 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
     this->CleanFiles.insert(outputs.begin() + 1, outputs.end());
   }
 
+  if (compilerGenerateDeps) {
+    depends.push_back(dependencyTimestamp);
+  }
+
   // Write the rule.
   this->WriteMakeRule(*this->BuildFileStream, nullptr, outputs, depends,
                       commands);
 
+  if (compilerGenerateDeps) {
+    // set back flags without dependency generation
+    vars.Flags = flags.c_str();
+  }
+
   bool do_preprocess_rules = lang_has_preprocessor &&
     this->LocalGenerator->GetCreatePreprocessedSourceRules();
   bool do_assembly_rules =
@@ -1381,10 +1516,10 @@ void cmMakefileTargetGenerator::WriteDeviceLinkRule(
 
     std::string registerFileCmd;
 
-    // The generated register file contains macros that when expanded register
-    // the device routines. Because the routines are the same for all
-    // architectures the register file will be the same too. Thus generate it
-    // only on the first invocation to reduce overhead.
+    // The generated register file contains macros that when expanded
+    // register the device routines. Because the routines are the same for
+    // all architectures the register file will be the same too. Thus
+    // generate it only on the first invocation to reduce overhead.
     if (fatbinaryDepends.size() == 1) {
       std::string registerFileRel =
         this->LocalGenerator->MaybeConvertToRelativePath(
@@ -1419,7 +1554,8 @@ void cmMakefileTargetGenerator::WriteDeviceLinkRule(
                                       fatbinaryOutputRel, fatbinaryDepends,
                                       { fatbinaryCommand }, false);
 
-  // Compile the stub that registers the kernels and contains the fatbinaries.
+  // Compile the stub that registers the kernels and contains the
+  // fatbinaries.
   cmRulePlaceholderExpander::RuleVariables vars;
   vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str();
   vars.CMTargetType =
@@ -1537,12 +1673,7 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
                          << this->GeneratorTarget->GetName() << "\n"
                          << variableName << " =";
   std::string object;
-  std::string lineContinue;
-  if (cmProp p = this->Makefile->GetDefinition("CMAKE_MAKE_LINE_CONTINUE")) {
-    lineContinue = *p;
-  } else {
-    lineContinue = "\\";
-  }
+  const auto& lineContinue = this->GlobalGenerator->LineContinueDirective;
 
   cmProp pchExtension = this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
 
@@ -1550,7 +1681,7 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
     if (cmSystemTools::StringEndsWith(obj, cmToCStr(pchExtension))) {
       continue;
     }
-    *this->BuildFileStream << " " << lineContinue << "\n";
+    *this->BuildFileStream << " " << lineContinue;
     *this->BuildFileStream
       << cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(
            obj, useWatcomQuote);
@@ -1573,7 +1704,7 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
   for (std::string const& obj : this->ExternalObjects) {
     object =
       this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, obj);
-    *this->BuildFileStream << " " << lineContinue << "\n";
+    *this->BuildFileStream << " " << lineContinue;
     *this->BuildFileStream
       << cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(
            obj, useWatcomQuote);
@@ -1837,9 +1968,9 @@ bool cmMakefileTargetGenerator::CheckUseResponseFileForObjects(
   if (size_t const limit = cmSystemTools::CalculateCommandLineLengthLimit()) {
     // Compute the total length of our list of object files with room
     // for argument separation and quoting.  This does not convert paths
-    // relative to CMAKE_CURRENT_BINARY_DIR like the final list will be, so the
-    // actual list will likely be much shorter than this.  However, in the
-    // worst case all objects will remain as absolute paths.
+    // relative to CMAKE_CURRENT_BINARY_DIR like the final list will be, so
+    // the actual list will likely be much shorter than this.  However, in
+    // the worst case all objects will remain as absolute paths.
     size_t length = 0;
     for (std::string const& obj : this->Objects) {
       length += obj.size() + 3;