Allow .o files for GN generated inputs.

tools/gn/target.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/target.h"
 
 #include <stddef.h>
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/scheduler.h"
+#include "tools/gn/source_file_type.h"
 #include "tools/gn/substitution_writer.h"
+#include "tools/gn/tool.h"
+#include "tools/gn/toolchain.h"
 #include "tools/gn/trace.h"
 
 namespace {
 
 typedef std::set<const Config*> ConfigSet;
 
 // Merges the public configs from the given target to the given config list.
 void MergePublicConfigsFrom(const Target* from_target,
                             UniqueVector<LabelConfigPair>* dest) {
   const UniqueVector<LabelConfigPair>& pub = from_target->public_configs();
@@ skipping 35 matching lines @@
                  "\n"
                  "Use source sets for intermediate targets instead.");
 }
 
 // Set check_private_deps to true for the first invocation since a target
 // can see all of its dependencies. For recursive invocations this will be set
 // to false to follow only public dependency paths.
 //
 // Pass a pointer to an empty set for the first invocation. This will be used
 // to avoid duplicate checking.
+//
+// Checking of object files is optional because it is much slower. This allows
+// us to check targets for normal outputs, and then as a second pass check
+// object files (since we know it will be an error otherwise). This allows
+// us to avoid computing all object file names in the common case.
 bool EnsureFileIsGeneratedByDependency(const Target* target,
                                        const OutputFile& file,
                                        bool check_private_deps,
+                                       bool consider_object_files,
                                        std::set<const Target*>* seen_targets) {
   if (seen_targets->find(target) != seen_targets->end())
     return false;  // Already checked this one and it's not found.
   seen_targets->insert(target);
 
   // Assume that we have relatively few generated inputs so brute-force
   // searching here is OK. If this becomes a bottleneck, consider storing
   // computed_outputs as a hash set.
   for (const OutputFile& cur : target->computed_outputs()) {
     if (file == cur)
       return true;
   }
 
+  // Check binary target intermediate files if requested.
+  if (consider_object_files && target->IsBinary()) {
+    std::vector<OutputFile> source_outputs;
+    for (const SourceFile& source : target->sources()) {
+      Toolchain::ToolType tool_type;
+      if (!target->GetOutputFilesForSource(source, &tool_type, &source_outputs))
+        continue;
+      if (std::find(source_outputs.begin(), source_outputs.end(), file) !=
+          source_outputs.end())
+        return true;
+    }
+  }
+
   // Check all public dependencies (don't do data ones since those are
   // runtime-only).
   for (const auto& pair : target->public_deps()) {
     if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
-                                          seen_targets))
+                                          consider_object_files, seen_targets))
       return true;  // Found a path.
   }
 
   // Only check private deps if requested.
   if (check_private_deps) {
     for (const auto& pair : target->private_deps()) {
       if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
+                                            consider_object_files,
                                             seen_targets))
         return true;  // Found a path.
     }
   }
   return false;
 }
 
 }  // namespace
 
 Target::Target(const Settings* settings, const Label& label)
@@ skipping 98 matching lines @@
     if (!CheckTestonly(err))
       return false;
     if (!CheckNoNestedStaticLibs(err))
       return false;
     CheckSourcesGenerated();
   }
 
   return true;
 }
 
+bool Target::IsBinary() const {
+  return output_type_ == EXECUTABLE ||
+         output_type_ == SHARED_LIBRARY ||
+         output_type_ == LOADABLE_MODULE ||
+         output_type_ == STATIC_LIBRARY ||
+         output_type_ == SOURCE_SET;
+}
+
 bool Target::IsLinkable() const {
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
 bool Target::IsFinal() const {
   return output_type_ == EXECUTABLE ||
          output_type_ == SHARED_LIBRARY ||
          output_type_ == LOADABLE_MODULE ||
          output_type_ == ACTION ||
          output_type_ == ACTION_FOREACH ||
@@ skipping 52 matching lines @@
             "Alas, I can not continue.",
             label().GetUserVisibleName(false).c_str(),
             GetStringForOutputType(output_type_),
             label().GetToolchainLabel().GetUserVisibleName(false).c_str(),
             Toolchain::ToolTypeToName(
                 toolchain->GetToolTypeForTargetFinalOutput(this)).c_str()));
   }
   return false;
 }
 
+bool Target::GetOutputFilesForSource(const SourceFile& source,
+                                     Toolchain::ToolType* computed_tool_type,
+                                     std::vector<OutputFile>* outputs) const {
+  outputs->clear();
+  *computed_tool_type = Toolchain::TYPE_NONE;
+
+  SourceFileType file_type = GetSourceFileType(source);
+  if (file_type == SOURCE_UNKNOWN)
+    return false;
+  if (file_type == SOURCE_O) {
+    // Object files just get passed to the output and not compiled.
+    outputs->push_back(OutputFile(settings()->build_settings(), source));
+    return true;
+  }
+
+  *computed_tool_type = toolchain_->GetToolTypeForSourceType(file_type);
+  if (*computed_tool_type == Toolchain::TYPE_NONE)
+    return false;  // No tool for this file (it's a header file or something).
+  const Tool* tool = toolchain_->GetTool(*computed_tool_type);
+  if (!tool)
+    return false;  // Tool does not apply for this toolchain.file.
+
+  // Figure out what output(s) this compiler produces.
+  SubstitutionWriter::ApplyListToCompilerAsOutputFile(
+      this, source, tool->outputs(), outputs);
+  return !outputs->empty();
+}
+
 void Target::PullDependentTargetConfigsFrom(const Target* dep) {
   MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
   MergePublicConfigsFrom(dep, &configs_);
 }
 
 void Target::PullDependentTargetConfigs() {
   for (const auto& pair : GetDeps(DEPS_LINKED))
     PullDependentTargetConfigsFrom(pair.ptr);
 }
 
@@ skipping 261 matching lines @@
 void Target::CheckSourceGenerated(const SourceFile& source) const {
   if (!IsStringInOutputDir(settings()->build_settings()->build_dir(),
                            source.value()))
     return;  // Not in output dir, this is OK.
 
   // Tell the scheduler about unknown files. This will be noted for later so
   // the list of files written by the GN build itself (often response files)
   // can be filtered out of this list.
   OutputFile out_file(settings()->build_settings(), source);
   std::set<const Target*> seen_targets;
-  if (!EnsureFileIsGeneratedByDependency(this, out_file, true, &seen_targets))
-    g_scheduler->AddUnknownGeneratedInput(this, source);
+  if (!EnsureFileIsGeneratedByDependency(this, out_file, true, false,
+                                         &seen_targets)) {
+    // Check object files (much slower and very rare) only if the "normal"
+    // output check failed.
+    seen_targets.clear();
+    if (!EnsureFileIsGeneratedByDependency(this, out_file, true, true,
+                                           &seen_targets))
+      g_scheduler->AddUnknownGeneratedInput(this, source);
+  }
 }