Support more configurability in GN toolchains

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 "base/bind.h"
+#include "base/strings/string_util.h"
 #include "tools/gn/config_values_extractors.h"
+#include "tools/gn/filesystem_utils.h"
 #include "tools/gn/scheduler.h"
+#include "tools/gn/substitution_writer.h"
 
 namespace {
 
 typedef std::set<const Config*> ConfigSet;
 
 // Merges the dependent configs from the given target to the given config list.
 void MergeDirectDependentConfigsFrom(const Target* from_target,
                                      UniqueVector<LabelConfigPair>* dest) {
   const UniqueVector<LabelConfigPair>& direct =
       from_target->direct_dependent_configs();
@@ skipping 14 matching lines @@
     dest->push_back(all[i]);
   }
 }
 
 }  // namespace
 
 Target::Target(const Settings* settings, const Label& label)
     : Item(settings, label),
       output_type_(UNKNOWN),
       all_headers_public_(true),
-      hard_dep_(false) {
+      hard_dep_(false),
+      toolchain_(NULL) {
 }
 
 Target::~Target() {
 }
 
 // static
 const char* Target::GetStringForOutputType(OutputType type) {
   switch (type) {
     case UNKNOWN:
       return "Unknown";
@@ skipping 21 matching lines @@
 Target* Target::AsTarget() {
   return this;
 }
 
 const Target* Target::AsTarget() const {
   return this;
 }
 
 void Target::OnResolved() {
   DCHECK(output_type_ != UNKNOWN);
+  DCHECK(toolchain_) << "Toolchain should have been set before resolving.";
 
   // Convert any groups we depend on to just direct dependencies on that
   // group's deps. We insert the new deps immediately after the group so that
   // the ordering is preserved. We need to keep the original group so that any
   // flags, etc. that it specifies itself are applied to us.
   for (size_t i = 0; i < deps_.size(); i++) {
     const Target* dep = deps_[i].ptr;
     if (dep->output_type_ == GROUP) {
+      // TODO(brettw) bug 403488 this should also handle datadeps.
       deps_.insert(deps_.begin() + i + 1, dep->deps_.begin(), dep->deps_.end());
       i += dep->deps_.size();
     }
   }
 
   // Copy our own dependent configs to the list of configs applying to us.
   configs_.Append(all_dependent_configs_.begin(), all_dependent_configs_.end());
   configs_.Append(direct_dependent_configs_.begin(),
                   direct_dependent_configs_.end());
 
   // Copy our own libs and lib_dirs to the final set. This will be from our
   // target and all of our configs. We do this specially since these must be
   // inherited through the dependency tree (other flags don't work this way).
   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
     const ConfigValues& cur = iter.cur();
     all_lib_dirs_.append(cur.lib_dirs().begin(), cur.lib_dirs().end());
     all_libs_.append(cur.libs().begin(), cur.libs().end());
   }
 
   if (output_type_ != GROUP) {
     // Don't pull target info like libraries and configs from dependencies into
     // a group target. When A depends on a group G, the G's dependents will
     // be treated as direct dependencies of A, so this is unnecessary and will
     // actually result in duplicated settings (since settings will also be
     // pulled from G to A in case G has configs directly on it).
     PullDependentTargetInfo();
   }
   PullForwardedDependentConfigs();
   PullRecursiveHardDeps();
+
+  FillOutputFiles();
 }
 
 bool Target::IsLinkable() const {
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
+std::string Target::GetComputedOutputName(bool include_prefix) const {
+  DCHECK(toolchain_)
+      << "Toolchain must be specified before getting the computed output name.";
+
+  const std::string& name = output_name_.empty() ? label().name()
+                                                 : output_name_;
+
+  std::string result;
+  if (include_prefix) {
+    const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
+    const std::string& prefix = tool->output_prefix();
+    // Only add the prefix if the name doesn't already have it.
+    if (!StartsWithASCII(name, prefix, true))
+      result = prefix;
+  }
+
+  result.append(name);
+  return result;
+}
+
+bool Target::SetToolchain(const Toolchain* toolchain, Err* err) {
+  DCHECK(!toolchain_);
+  DCHECK(output_type_ != UNKNOWN);

[jamesr, 2014/08/19 19:30:42]

DCHECK_NE will give better output on failure

+  toolchain_ = toolchain;
+
+  const Tool* tool = toolchain->GetToolForTargetFinalOutput(this);
+  if (tool)
+    return true;
+
+  // Tool not specified for this target type.
+  if (err) {
+    *err = Err(defined_from(), "This target uses an undefined tool.",
+        "The target " + label().GetUserVisibleName(false) +

[jamesr, 2014/08/19 19:30:42]

this could use some stringprintf, imo. it's really hard to read the mix of
literals and expressions

+        "\nof type \"" + GetStringForOutputType(output_type_) +
+        "\"\nuses toolchain " +
+        label().GetToolchainLabel().GetUserVisibleName(false) +
+        "\nwhich doesn't have the tool \"" +
+        Toolchain::ToolTypeToName(
+            toolchain->GetToolTypeForTargetFinalOutput(this)) +
+        "\" defined.\n\nAlas, I can not continue.");
+  }
+  return false;
+}
+
 void Target::PullDependentTargetInfo() {
   // Gather info from our dependents we need.
   for (size_t dep_i = 0; dep_i < deps_.size(); dep_i++) {
     const Target* dep = deps_[dep_i].ptr;
     MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
     MergeDirectDependentConfigsFrom(dep, &configs_);
 
     // Direct dependent libraries.
     if (dep->output_type() == STATIC_LIBRARY ||
         dep->output_type() == SHARED_LIBRARY ||
@@ skipping 44 matching lines @@
 
     // Android STL doesn't like insert(begin, end) so do it manually.
     // TODO(brettw) this can be changed to insert(dep->begin(), dep->end()) when
     // Android uses a better STL.
     for (std::set<const Target*>::const_iterator cur =
              dep->recursive_hard_deps().begin();
          cur != dep->recursive_hard_deps().end(); ++cur)
       recursive_hard_deps_.insert(*cur);
   }
 }
+
+void Target::FillOutputFiles() {
+  const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
+  switch (output_type_) {
+    case GROUP:
+    case SOURCE_SET:
+    case COPY_FILES:
+    case ACTION:
+    case ACTION_FOREACH: {
+      // These don't get linked to and use stamps which should be the first
+      // entry in the outputs. These stamps are named
+      // "<target_out_dir>/<targetname>.stamp".
+      dependency_output_file_ = GetTargetOutputDirAsOutputFile(this);
+      dependency_output_file_.value().append(GetComputedOutputName(true));
+      dependency_output_file_.value().append(".stamp");
+      break;
+    }
+    case EXECUTABLE:
+      // Executables don't get linked to, but the first output is used for
+      // dependency management.
+      CHECK(tool->outputs().list().size() >= 1);

[jamesr, 2014/08/19 19:30:42]

CHECK_GE produces slightly better output on failure (i guess if it fails you
know it's 0 anyway)

+      dependency_output_file_ =
+          SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+              this, tool, tool->outputs().list()[0]);
+      break;
+    case STATIC_LIBRARY:
+      // Static libraries both have dependencies and linking going off of the
+      // first output.
+      CHECK(tool->outputs().list().size() >= 1);
+      link_output_file_ = dependency_output_file_ =
+          SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+              this, tool, tool->outputs().list()[0]);
+      break;
+    case SHARED_LIBRARY:
+      CHECK(tool->outputs().list().size() >= 1);
+      if (tool->link_output().empty() && tool->depend_output().empty()) {
+        // Default behavior, use the first output file for both.
+        link_output_file_ = dependency_output_file_ =
+            SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+                this, tool, tool->outputs().list()[0]);
+      } else {
+        // Use the tool-specified ones.
+        if (!tool->link_output().empty()) {
+          link_output_file_ =
+              SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+                  this, tool, tool->link_output());
+        }
+        if (!tool->depend_output().empty()) {
+          dependency_output_file_ =
+              SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+                  this, tool, tool->link_output());
+        }
+      }
+      break;
+    case UNKNOWN:
+    default:
+      NOTREACHED();
+  }
+}