GN: Use implicit dependency for binary input deps

tools/gn/ninja_binary_target_writer.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/ninja_binary_target_writer.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <cstring>
@@ skipping 252 matching lines @@
 }
 
 void NinjaBinaryTargetWriter::Run() {
   // Figure out what source types are needed.
   SourceFileTypeSet used_types;
   for (const auto& source : target_->sources())
     used_types.Set(GetSourceFileType(source));
 
   WriteCompilerVars(used_types);
 
+  OutputFile input_dep = WriteInputsStampAndGetDep();
+
   // The input dependencies will be an order-only dependency. This will cause
   // Ninja to make sure the inputs are up to date before compiling this source,
   // but changes in the inputs deps won't cause the file to be recompiled.
   //
   // This is important to prevent changes in unrelated actions that are
   // upstream of this target from causing everything to be recompiled.
   //
   // Why can we get away with this rather than using implicit deps ("|", which
   // will force rebuilds when the inputs change)? For source code, the
   // computed dependencies of all headers will be computed by the compiler,
@@ skipping 11 matching lines @@
   // built first. This is exactly what Ninja's order-only dependencies
   // expresses.
   OutputFile order_only_dep =
       WriteInputDepsStampAndGetDep(std::vector<const Target*>());
 
   // For GCC builds, the .gch files are not object files, but still need to be
   // added as explicit dependencies below. The .gch output files are placed in
   // |pch_other_files|. This is to prevent linking against them.
   std::vector<OutputFile> pch_obj_files;
   std::vector<OutputFile> pch_other_files;
-  WritePCHCommands(used_types, order_only_dep,
+  WritePCHCommands(used_types, input_dep, order_only_dep,
                    &pch_obj_files, &pch_other_files);
   std::vector<OutputFile>* pch_files = !pch_obj_files.empty() ?
       &pch_obj_files : &pch_other_files;
 
   // Treat all pch output files as explicit dependencies of all
   // compiles that support them. Some notes:
   //
   //  - On Windows, the .pch file is the input to the compile, not the
   //    precompiled header's corresponding object file that we're using here.
   //    But Ninja's depslog doesn't support multiple outputs from the
   //    precompiled header compile step (it outputs both the .pch file and a
   //    corresponding .obj file). So we consistently list the .obj file and the
   //    .pch file we really need comes along with it.
   //
   //  - GCC .gch files are not object files, therefore they are not added to the
   //    object file list.
   std::vector<OutputFile> obj_files;
   std::vector<SourceFile> other_files;
-  WriteSources(*pch_files, order_only_dep, &obj_files, &other_files);
+  WriteSources(*pch_files, input_dep, order_only_dep, &obj_files, &other_files);
 
   // Link all MSVC pch object files. The vector will be empty on GCC toolchains.
   obj_files.insert(obj_files.end(), pch_obj_files.begin(), pch_obj_files.end());
   if (!CheckForDuplicateObjectFiles(obj_files))
     return;
 
   if (target_->output_type() == Target::SOURCE_SET) {
     WriteSourceSetStamp(obj_files);
 #ifndef NDEBUG
     // Verify that the function that separately computes a source set's object
@@ skipping 60 matching lines @@
                  Toolchain::TYPE_OBJC, &ConfigValues::cflags_objc, opts);
   }
   if (used_types.Get(SOURCE_MM)) {
     WriteOneFlag(SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
                  Toolchain::TYPE_OBJCXX, &ConfigValues::cflags_objcc, opts);
   }
 
   WriteSharedVars(subst);
 }
 
+OutputFile NinjaBinaryTargetWriter::WriteInputsStampAndGetDep() const {
+  CHECK(target_->toolchain())
+      << "Toolchain not set on target "
+      << target_->label().GetUserVisibleName(true);
+
+  if (target_->inputs().size() == 0)
+    return OutputFile();  // No inputs
+
+  // If we only have one input, return it directly instead of writing a stamp
+  // file for it.
+  if (target_->inputs().size() == 1)
+    return OutputFile(settings_->build_settings(), target_->inputs()[0]);
+
+  // Make a stamp file.
+  OutputFile input_stamp_file(
+      RebasePath(GetTargetOutputDir(target_).value(),
+                 settings_->build_settings()->build_dir(),
+                 settings_->build_settings()->root_path_utf8()));
+  input_stamp_file.value().append(target_->label().name());
+  input_stamp_file.value().append(".inputs.stamp");
+
+  out_ << "build ";
+  path_output_.WriteFile(out_, input_stamp_file);
+  out_ << ": "
+       << GetNinjaRulePrefixForToolchain(settings_)
+       << Toolchain::ToolTypeToName(Toolchain::TYPE_STAMP);
+
+  // File inputs.
+  for (const auto& input : target_->inputs()) {
+    out_ << " ";
+    path_output_.WriteFile(out_, input);
+  }
+
+  out_ << "\n";
+  return input_stamp_file;
+}
+
 void NinjaBinaryTargetWriter::WriteOneFlag(
     SubstitutionType subst_enum,
     bool has_precompiled_headers,
     Toolchain::ToolType tool_type,
     const std::vector<std::string>& (ConfigValues::* getter)() const,
     EscapeOptions flag_escape_options) {
   if (!target_->toolchain()->substitution_bits().used[subst_enum])
     return;
 
   out_ << kSubstitutionNinjaNames[subst_enum] << " =";
@@ skipping 32 matching lines @@
     }
   } else {
     RecursiveTargetConfigStringsToStream(target_, getter,
                                          flag_escape_options, out_);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WritePCHCommands(
     const SourceFileTypeSet& used_types,
+    const OutputFile& input_dep,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files,
     std::vector<OutputFile>* other_files) {
   if (!target_->config_values().has_precompiled_headers())
     return;
 
   const Tool* tool_c = target_->toolchain()->GetTool(Toolchain::TYPE_CC);
   if (tool_c &&
       tool_c->precompiled_header_type() != Tool::PCH_NONE &&
       used_types.Get(SOURCE_C)) {
     WritePCHCommand(SUBSTITUTION_CFLAGS_C,
                     Toolchain::TYPE_CC,
                     tool_c->precompiled_header_type(),
-                    order_only_dep, object_files, other_files);
+                    input_dep, order_only_dep, object_files, other_files);
   }
   const Tool* tool_cxx = target_->toolchain()->GetTool(Toolchain::TYPE_CXX);
   if (tool_cxx &&
       tool_cxx->precompiled_header_type() != Tool::PCH_NONE &&
       used_types.Get(SOURCE_CPP)) {
     WritePCHCommand(SUBSTITUTION_CFLAGS_CC,
                     Toolchain::TYPE_CXX,
                     tool_cxx->precompiled_header_type(),
-                    order_only_dep, object_files, other_files);
+                    input_dep, order_only_dep, object_files, other_files);
   }
 
   const Tool* tool_objc = target_->toolchain()->GetTool(Toolchain::TYPE_OBJC);
   if (tool_objc &&
       tool_objc->precompiled_header_type() == Tool::PCH_GCC &&
       used_types.Get(SOURCE_M)) {
     WritePCHCommand(SUBSTITUTION_CFLAGS_OBJC,
                     Toolchain::TYPE_OBJC,
                     tool_objc->precompiled_header_type(),
-                    order_only_dep, object_files, other_files);
+                    input_dep, order_only_dep, object_files, other_files);
   }
 
   const Tool* tool_objcxx =
       target_->toolchain()->GetTool(Toolchain::TYPE_OBJCXX);
   if (tool_objcxx &&
       tool_objcxx->precompiled_header_type() == Tool::PCH_GCC &&
       used_types.Get(SOURCE_MM)) {
     WritePCHCommand(SUBSTITUTION_CFLAGS_OBJCC,
                     Toolchain::TYPE_OBJCXX,
                     tool_objcxx->precompiled_header_type(),
-                    order_only_dep, object_files, other_files);
+                    input_dep, order_only_dep, object_files, other_files);
   }
 }
 
 void NinjaBinaryTargetWriter::WritePCHCommand(
     SubstitutionType flag_type,
     Toolchain::ToolType tool_type,
     Tool::PrecompiledHeaderType header_type,
+    const OutputFile& input_dep,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files,
     std::vector<OutputFile>* other_files) {
   switch (header_type) {
     case Tool::PCH_MSVC:
-      WriteWindowsPCHCommand(flag_type, tool_type, order_only_dep,
+      WriteWindowsPCHCommand(flag_type, tool_type, input_dep, order_only_dep,
                              object_files);
       break;
     case Tool::PCH_GCC:
-      WriteGCCPCHCommand(flag_type, tool_type, order_only_dep,
+      WriteGCCPCHCommand(flag_type, tool_type, input_dep, order_only_dep,
                          other_files);
       break;
     case Tool::PCH_NONE:
       NOTREACHED() << "Cannot write a PCH command with no PCH header type";
       break;
   }
 }
 
 void NinjaBinaryTargetWriter::WriteGCCPCHCommand(
     SubstitutionType flag_type,
     Toolchain::ToolType tool_type,
+    const OutputFile& input_dep,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* gch_files) {
   // Compute the pch output file (it will be language-specific).
   std::vector<OutputFile> outputs;
   GetPCHOutputFiles(target_, tool_type, &outputs);
   if (outputs.empty())
     return;
 
   gch_files->insert(gch_files->end(), outputs.begin(), outputs.end());
 
+  std::vector<OutputFile> extra_deps;
+  if (!input_dep.value().empty())
+    extra_deps.push_back(input_dep);
+
   // Build line to compile the file.
   WriteCompilerBuildLine(target_->config_values().precompiled_source(),
-                         std::vector<OutputFile>(), order_only_dep, tool_type,
-                         outputs);
+                         extra_deps, order_only_dep, tool_type, outputs);
 
   // This build line needs a custom language-specific flags value. Rule-specific
   // variables are just indented underneath the rule line.
   out_ << "  " << kSubstitutionNinjaNames[flag_type] << " =";
 
   // Each substitution flag is overwritten in the target rule to replace the
   // implicitly generated -include flag with the -x <header lang> flag required
   // for .gch targets.
   EscapeOptions opts = GetFlagOptions();
   if (tool_type == Toolchain::TYPE_CC) {
@@ skipping 14 matching lines @@
   out_ << " -x " << GetPCHLangForToolType(tool_type);
 
   // Write two blank lines to help separate the PCH build lines from the
   // regular source build lines.
   out_ << std::endl << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteWindowsPCHCommand(
     SubstitutionType flag_type,
     Toolchain::ToolType tool_type,
+    const OutputFile& input_dep,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files) {
   // Compute the pch output file (it will be language-specific).
   std::vector<OutputFile> outputs;
   GetPCHOutputFiles(target_, tool_type, &outputs);
   if (outputs.empty())
     return;
 
   object_files->insert(object_files->end(), outputs.begin(), outputs.end());
 
+  std::vector<OutputFile> extra_deps;
+  if (!input_dep.value().empty())
+    extra_deps.push_back(input_dep);
+
   // Build line to compile the file.
   WriteCompilerBuildLine(target_->config_values().precompiled_source(),
-                         std::vector<OutputFile>(), order_only_dep, tool_type,
-                         outputs);
+                         extra_deps, order_only_dep, tool_type, outputs);
 
   // This build line needs a custom language-specific flags value. Rule-specific
   // variables are just indented underneath the rule line.
   out_ << "  " << kSubstitutionNinjaNames[flag_type] << " =";
 
   // Append the command to generate the .pch file.
   // This adds the value to the existing flag instead of overwriting it.
   out_ << " ${" << kSubstitutionNinjaNames[flag_type] << "}";
   out_ << " /Yc" << target_->config_values().precompiled_header();
 
   // Write two blank lines to help separate the PCH build lines from the
   // regular source build lines.
   out_ << std::endl << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
     const std::vector<OutputFile>& pch_deps,
+    const OutputFile& input_dep,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files,
     std::vector<SourceFile>* other_files) {
   object_files->reserve(object_files->size() + target_->sources().size());
 
   std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
   std::vector<OutputFile> deps;
   for (const auto& source : target_->sources()) {
     // Clear the vector but maintain the max capacity to prevent reallocations.
     deps.resize(0);
     Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
     if (!target_->GetOutputFilesForSource(source, &tool_type, &tool_outputs)) {
       if (GetSourceFileType(source) == SOURCE_DEF)
         other_files->push_back(source);
       continue;  // No output for this source.
     }
 
+    if (!input_dep.value().empty())
+      deps.push_back(input_dep);
+
     if (tool_type != Toolchain::TYPE_NONE) {
       // Only include PCH deps that correspond to the tool type, for instance,
       // do not specify target_name.precompile.cc.obj (a CXX PCH file) as a dep
       // for the output of a C tool type.
       //
       // This makes the assumption that pch_deps only contains pch output files
       // with the naming scheme specified in GetWindowsPCHObjectExtension or
       // GetGCCPCHOutputExtension.
       const Tool* tool = target_->toolchain()->GetTool(tool_type);
       if (tool->precompiled_header_type() != Tool::PCH_NONE) {
@@ skipping 381 matching lines @@
           "\n"
           "In the latter case, either rename one of the files or move one of\n"
           "the sources to a separate source_set to avoid them both being in\n"
           "the same target.");
       g_scheduler->FailWithError(err);
       return false;
     }
   }
   return true;
 }