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);
 
-  // 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.
+  // The input dependencies will be an implicit dependency. This will cause
+  // Ninja to make sure the inputs are up to date before compiling this source;
+  // changes in the inputs deps will 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,
-  // which will cause source rebuilds if any "real" upstream dependencies
-  // change.
-  //
-  // If a .cc file is generated by an input dependency, Ninja will see the
-  // input to the build rule doesn't exist, and that it is an output from a
-  // previous step, and build the previous step first. This is a "real"
-  // dependency and doesn't need | or || to express.
-  //
-  // The only case where this rule matters is for the first build where no .d
-  // files exist, and Ninja doesn't know what that source file depends on. In
-  // this case it's sufficient to ensure that the upstream dependencies are
-  // built first. This is exactly what Ninja's order-only dependencies
-  // expresses.
-  OutputFile order_only_dep =
+  // This is to make sure that we force rebuild the source when the inputs
+  // change. Why cannot we rely on the dependencies computed by the compiler?
+  // These dependencies only include headers and might miss other resources
+  // that are used by the input file.
+  OutputFile input_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,
                    &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, &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 112 matching lines @@
     }
   } else {
     RecursiveTargetConfigStringsToStream(target_, getter,
                                          flag_escape_options, out_);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WritePCHCommands(
     const SourceFileTypeSet& used_types,
-    const OutputFile& order_only_dep,
+    const OutputFile& input_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, 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, 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, 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, object_files, other_files);
   }
 }
 
 void NinjaBinaryTargetWriter::WritePCHCommand(
     SubstitutionType flag_type,
     Toolchain::ToolType tool_type,
     Tool::PrecompiledHeaderType header_type,
-    const OutputFile& order_only_dep,
+    const OutputFile& input_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,
                              object_files);
       break;
     case Tool::PCH_GCC:
-      WriteGCCPCHCommand(flag_type, tool_type, order_only_dep,
+      WriteGCCPCHCommand(flag_type, tool_type, input_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& order_only_dep,
+    const OutputFile& input_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> deps;
+  if (!input_dep.value().empty()) {

[brettw, 2016/06/16 19:41:34]

No {}, same for the additions below.

[Petr Hosek, 2016/06/16 23:11:47]

Done.

+    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);
+                         deps, 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& order_only_dep,
+    const OutputFile& input_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> deps;
+  if (!input_dep.value().empty()) {
+    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);
+                         deps, 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& order_only_dep,
+    const OutputFile& input_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) {
         for (const auto& dep : pch_deps) {
           const std::string& output_value = dep.value();
           size_t extension_offset = FindExtensionOffset(output_value);
           if (extension_offset == std::string::npos)
             continue;
           std::string output_extension;
           if (tool->precompiled_header_type() == Tool::PCH_MSVC) {
             output_extension = GetWindowsPCHObjectExtension(
                 tool_type, output_value.substr(extension_offset - 1));
           } else if (tool->precompiled_header_type() == Tool::PCH_GCC) {
             output_extension = GetGCCPCHOutputExtension(tool_type);
           }
           if (output_value.compare(output_value.size() -
               output_extension.size(), output_extension.size(),
               output_extension) == 0) {
             deps.push_back(dep);
           }
         }
       }
-      WriteCompilerBuildLine(source, deps, order_only_dep, tool_type,
-                             tool_outputs);
+      WriteCompilerBuildLine(source, deps, tool_type, tool_outputs);
     }
 
     // It's theoretically possible for a compiler to produce more than one
     // output, but we'll only link to the first output.
     object_files->push_back(tool_outputs[0]);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteCompilerBuildLine(
     const SourceFile& source,
     const std::vector<OutputFile>& extra_deps,
-    const OutputFile& order_only_dep,
     Toolchain::ToolType tool_type,
     const std::vector<OutputFile>& outputs) {
   out_ << "build";
   path_output_.WriteFiles(out_, outputs);
 
   out_ << ": " << rule_prefix_ << Toolchain::ToolTypeToName(tool_type);
   out_ << " ";
   path_output_.WriteFile(out_, source);
 
   if (!extra_deps.empty()) {
     out_ << " |";
     for (const OutputFile& dep : extra_deps) {
       out_ << " ";
       path_output_.WriteFile(out_, dep);
     }
   }
-
-  if (!order_only_dep.value().empty()) {
-    out_ << " || ";
-    path_output_.WriteFile(out_, order_only_dep);
-  }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteLinkerStuff(
     const std::vector<OutputFile>& object_files,
     const std::vector<SourceFile>& other_files) {
   std::vector<OutputFile> output_files;
   SubstitutionWriter::ApplyListToLinkerAsOutputFile(
       target_, tool_, tool_->outputs(), &output_files);
 
   out_ << "build";
   path_output_.WriteFiles(out_, output_files);
 
   out_ << ": " << rule_prefix_
        << Toolchain::ToolTypeToName(
               target_->toolchain()->GetToolTypeForTargetFinalOutput(target_));
 
   UniqueVector<OutputFile> extra_object_files;
   UniqueVector<const Target*> linkable_deps;
   UniqueVector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // Object files.
   path_output_.WriteFiles(out_, object_files);
   path_output_.WriteFiles(out_, extra_object_files);
 
   // Dependencies.
-  std::vector<OutputFile> implicit_deps;
+  std::vector<OutputFile> input_deps;
   std::vector<OutputFile> solibs;
   for (const Target* cur : linkable_deps) {
     // All linkable deps should have a link output file.
     DCHECK(!cur->link_output_file().value().empty())
         << "No link output file for "
         << target_->label().GetUserVisibleName(false);
 
     if (cur->dependency_output_file().value() !=
         cur->link_output_file().value()) {
       // This is a shared library with separate link and deps files. Save for
       // later.
-      implicit_deps.push_back(cur->dependency_output_file());
+      input_deps.push_back(cur->dependency_output_file());
       solibs.push_back(cur->link_output_file());
     } else {
       // Normal case, just link to this target.
       out_ << " ";
       path_output_.WriteFile(out_, cur->link_output_file());
     }
   }
 
   const SourceFile* optional_def_file = nullptr;
   if (!other_files.empty()) {
     for (const SourceFile& src_file : other_files) {
       if (GetSourceFileType(src_file) == SOURCE_DEF) {
         optional_def_file = &src_file;
-        implicit_deps.push_back(
+        input_deps.push_back(
             OutputFile(settings_->build_settings(), src_file));
         break;  // Only one def file is allowed.
       }
     }
   }
 
   // Libraries specified by paths.
   const OrderedSet<LibFile>& libs = target_->all_libs();
   for (size_t i = 0; i < libs.size(); i++) {
     if (libs[i].is_source_file()) {
-      implicit_deps.push_back(
+      input_deps.push_back(
           OutputFile(settings_->build_settings(), libs[i].source_file()));
     }
   }
 
   // Append implicit dependencies collected above.
-  if (!implicit_deps.empty()) {
+  if (!input_deps.empty()) {
     out_ << " |";
-    path_output_.WriteFiles(out_, implicit_deps);
+    path_output_.WriteFiles(out_, input_deps);
   }
 
   // Append data dependencies as order-only dependencies.
   //
   // This will include data dependencies and input dependencies (like when
   // this target depends on an action). Having the data dependencies in this
   // list ensures that the data is available at runtime when the user builds
   // this target.
   //
   // The action dependencies are not strictly necessary in this case. They
@@ skipping 243 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;
 }