tools/gn/target.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/gn/target.h"
   6
   7 #include "base/bind.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "tools/gn/config_values_extractors.h"
  11 #include "tools/gn/deps_iterator.h"
  12 #include "tools/gn/filesystem_utils.h"
  13 #include "tools/gn/scheduler.h"
  14 #include "tools/gn/substitution_writer.h"
  15
  16 namespace {
  17
  18 typedef std::set<const Config*> ConfigSet;
  19
  20 // Merges the public configs from the given target to the given config list.
  21 void MergePublicConfigsFrom(const Target* from_target,
  22                             UniqueVector<LabelConfigPair>* dest) {
  23   const UniqueVector<LabelConfigPair>& pub = from_target->public_configs();
  24   dest->Append(pub.begin(), pub.end());
  25 }
  26
  27 // Like MergePublicConfigsFrom above except does the "all dependent" ones. This
  28 // additionally adds all configs to the all_dependent_configs_ of the dest
  29 // target given in *all_dest.
  30 void MergeAllDependentConfigsFrom(const Target* from_target,
  31                                   UniqueVector<LabelConfigPair>* dest,
  32                                   UniqueVector<LabelConfigPair>* all_dest) {
  33   const UniqueVector<LabelConfigPair>& all =
  34       from_target->all_dependent_configs();
  35   for (size_t i = 0; i < all.size(); i++) {
  36     all_dest->push_back(all[i]);
  37     dest->push_back(all[i]);
  38   }
  39 }
  40
  41 Err MakeTestOnlyError(const Target* from, const Target* to) {
  42   return Err(from->defined_from(), "Test-only dependency not allowed.",
  43       from->label().GetUserVisibleName(false) + "\n"
  44       "which is NOT marked testonly can't depend on\n" +
  45       to->label().GetUserVisibleName(false) + "\n"
  46       "which is marked testonly. Only targets with \"testonly = true\"\n"
  47       "can depend on other test-only targets.\n"
  48       "\n"
  49       "Either mark it test-only or don't do this dependency.");
  50 }
  51
  52 Err MakeStaticLibDepsError(const Target* from, const Target* to) {
  53   return Err(from->defined_from(),
  54              "Complete static libraries can't depend on static libraries.",
  55              from->label().GetUserVisibleName(false) +
  56                  "\n"
  57                  "which is a complete static library can't depend on\n" +
  58                  to->label().GetUserVisibleName(false) +
  59                  "\n"
  60                  "which is a static library.\n"
  61                  "\n"
  62                  "Use source sets for intermediate targets instead.");
  63 }
  64
  65 }  // namespace
  66
  67 Target::Target(const Settings* settings, const Label& label)
  68     : Item(settings, label),
  69       output_type_(UNKNOWN),
  70       all_headers_public_(true),
  71       check_includes_(true),
  72       complete_static_lib_(false),
  73       testonly_(false),
  74       hard_dep_(false),
  75       toolchain_(NULL) {
  76 }
  77
  78 Target::~Target() {
  79 }
  80
  81 // static
  82 const char* Target::GetStringForOutputType(OutputType type) {
  83   switch (type) {
  84     case UNKNOWN:
  85       return "Unknown";
  86     case GROUP:
  87       return "Group";
  88     case EXECUTABLE:
  89       return "Executable";
  90     case SHARED_LIBRARY:
  91       return "Shared library";
  92     case STATIC_LIBRARY:
  93       return "Static library";
  94     case SOURCE_SET:
  95       return "Source set";
  96     case COPY_FILES:
  97       return "Copy";
  98     case ACTION:
  99       return "Action";
 100     case ACTION_FOREACH:
 101       return "ActionForEach";
 102     default:
 103       return "";
 104   }
 105 }
 106
 107 Target* Target::AsTarget() {
 108   return this;
 109 }
 110
 111 const Target* Target::AsTarget() const {
 112   return this;
 113 }
 114
 115 bool Target::OnResolved(Err* err) {
 116   DCHECK(output_type_ != UNKNOWN);
 117   DCHECK(toolchain_) << "Toolchain should have been set before resolving.";
 118
 119   // Copy our own dependent configs to the list of configs applying to us.
 120   configs_.Append(all_dependent_configs_.begin(), all_dependent_configs_.end());
 121   MergePublicConfigsFrom(this, &configs_);
 122
 123   // Copy our own libs and lib_dirs to the final set. This will be from our
 124   // target and all of our configs. We do this specially since these must be
 125   // inherited through the dependency tree (other flags don't work this way).
 126   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
 127     const ConfigValues& cur = iter.cur();
 128     all_lib_dirs_.append(cur.lib_dirs().begin(), cur.lib_dirs().end());
 129     all_libs_.append(cur.libs().begin(), cur.libs().end());
 130   }
 131
 132   PullDependentTargetInfo();
 133   PullForwardedDependentConfigs();
 134   PullRecursiveHardDeps();
 135
 136   FillOutputFiles();
 137
 138   if (!CheckVisibility(err))
 139     return false;
 140   if (!CheckTestonly(err))
 141     return false;
 142   if (!CheckNoNestedStaticLibs(err))
 143     return false;
 144
 145   return true;
 146 }
 147
 148 bool Target::IsLinkable() const {
 149   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 150 }
 151
 152 bool Target::IsFinal() const {
 153   return output_type_ == EXECUTABLE || output_type_ == SHARED_LIBRARY ||
 154          (output_type_ == STATIC_LIBRARY && complete_static_lib_);
 155 }
 156
 157 std::string Target::GetComputedOutputName(bool include_prefix) const {
 158   DCHECK(toolchain_)
 159       << "Toolchain must be specified before getting the computed output name.";
 160
 161   const std::string& name = output_name_.empty() ? label().name()
 162                                                  : output_name_;
 163
 164   std::string result;
 165   if (include_prefix) {
 166     const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
 167     const std::string& prefix = tool->output_prefix();
 168     // Only add the prefix if the name doesn't already have it.
 169     if (!StartsWithASCII(name, prefix, true))
 170       result = prefix;
 171   }
 172
 173   result.append(name);
 174   return result;
 175 }
 176
 177 bool Target::SetToolchain(const Toolchain* toolchain, Err* err) {
 178   DCHECK(!toolchain_);
 179   DCHECK_NE(UNKNOWN, output_type_);
 180   toolchain_ = toolchain;
 181
 182   const Tool* tool = toolchain->GetToolForTargetFinalOutput(this);
 183   if (tool)
 184     return true;
 185
 186   // Tool not specified for this target type.
 187   if (err) {
 188     *err = Err(defined_from(), "This target uses an undefined tool.",
 189         base::StringPrintf(
 190             "The target %s\n"
 191             "of type \"%s\"\n"
 192             "uses toolchain %s\n"
 193             "which doesn't have the tool \"%s\" defined.\n\n"
 194             "Alas, I can not continue.",
 195             label().GetUserVisibleName(false).c_str(),
 196             GetStringForOutputType(output_type_),
 197             label().GetToolchainLabel().GetUserVisibleName(false).c_str(),
 198             Toolchain::ToolTypeToName(
 199                 toolchain->GetToolTypeForTargetFinalOutput(this)).c_str()));
 200   }
 201   return false;
 202 }
 203
 204 void Target::PullDependentTargetInfo() {
 205   // Gather info from our dependents we need.
 206   for (DepsIterator iter(this, DepsIterator::LINKED_ONLY); !iter.done();
 207        iter.Advance()) {
 208     const Target* dep = iter.target();
 209     MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
 210     MergePublicConfigsFrom(dep, &configs_);
 211
 212     // Direct dependent libraries.
 213     if (dep->output_type() == STATIC_LIBRARY ||
 214         dep->output_type() == SHARED_LIBRARY ||
 215         dep->output_type() == SOURCE_SET)
 216       inherited_libraries_.push_back(dep);
 217
 218     // Inherited libraries and flags are inherited across static library
 219     // boundaries.
 220     if (!dep->IsFinal()) {
 221       inherited_libraries_.Append(dep->inherited_libraries().begin(),
 222                                   dep->inherited_libraries().end());
 223
 224       // Inherited library settings.
 225       all_lib_dirs_.append(dep->all_lib_dirs());
 226       all_libs_.append(dep->all_libs());
 227     }
 228   }
 229 }
 230
 231 void Target::PullForwardedDependentConfigs() {
 232   // Pull public configs from each of our dependency's public deps.
 233   for (size_t dep = 0; dep < public_deps_.size(); dep++)
 234     PullForwardedDependentConfigsFrom(public_deps_[dep].ptr);
 235
 236   // Forward public configs if explicitly requested.
 237   for (size_t dep = 0; dep < forward_dependent_configs_.size(); dep++) {
 238     const Target* from_target = forward_dependent_configs_[dep].ptr;
 239
 240     // The forward_dependent_configs_ must be in the deps (public or private)
 241     // already, so we don't need to bother copying to our configs, only
 242     // forwarding.
 243     DCHECK(std::find_if(private_deps_.begin(), private_deps_.end(),
 244                         LabelPtrPtrEquals<Target>(from_target)) !=
 245                private_deps_.end() ||
 246            std::find_if(public_deps_.begin(), public_deps_.end(),
 247                         LabelPtrPtrEquals<Target>(from_target)) !=
 248                public_deps_.end());
 249
 250     PullForwardedDependentConfigsFrom(from_target);
 251   }
 252 }
 253
 254 void Target::PullForwardedDependentConfigsFrom(const Target* from) {
 255   public_configs_.Append(from->public_configs().begin(),
 256                          from->public_configs().end());
 257 }
 258
 259 void Target::PullRecursiveHardDeps() {
 260   for (DepsIterator iter(this, DepsIterator::LINKED_ONLY); !iter.done();
 261        iter.Advance()) {
 262     if (iter.target()->hard_dep())
 263       recursive_hard_deps_.insert(iter.target());
 264
 265     // Android STL doesn't like insert(begin, end) so do it manually.
 266     // TODO(brettw) this can be changed to
 267     // insert(iter.target()->begin(), iter.target()->end())
 268     // when Android uses a better STL.
 269     for (std::set<const Target*>::const_iterator cur =
 270              iter.target()->recursive_hard_deps().begin();
 271          cur != iter.target()->recursive_hard_deps().end(); ++cur)
 272       recursive_hard_deps_.insert(*cur);
 273   }
 274 }
 275
 276 void Target::FillOutputFiles() {
 277   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
 278   switch (output_type_) {
 279     case GROUP:
 280     case SOURCE_SET:
 281     case COPY_FILES:
 282     case ACTION:
 283     case ACTION_FOREACH: {
 284       // These don't get linked to and use stamps which should be the first
 285       // entry in the outputs. These stamps are named
 286       // "<target_out_dir>/<targetname>.stamp".
 287       dependency_output_file_ = GetTargetOutputDirAsOutputFile(this);
 288       dependency_output_file_.value().append(GetComputedOutputName(true));
 289       dependency_output_file_.value().append(".stamp");
 290       break;
 291     }
 292     case EXECUTABLE:
 293       // Executables don't get linked to, but the first output is used for
 294       // dependency management.
 295       CHECK_GE(tool->outputs().list().size(), 1u);
 296       dependency_output_file_ =
 297           SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 298               this, tool, tool->outputs().list()[0]);
 299       break;
 300     case STATIC_LIBRARY:
 301       // Static libraries both have dependencies and linking going off of the
 302       // first output.
 303       CHECK(tool->outputs().list().size() >= 1);
 304       link_output_file_ = dependency_output_file_ =
 305           SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 306               this, tool, tool->outputs().list()[0]);
 307       break;
 308     case SHARED_LIBRARY:
 309       CHECK(tool->outputs().list().size() >= 1);
 310       if (tool->link_output().empty() && tool->depend_output().empty()) {
 311         // Default behavior, use the first output file for both.
 312         link_output_file_ = dependency_output_file_ =
 313             SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 314                 this, tool, tool->outputs().list()[0]);
 315       } else {
 316         // Use the tool-specified ones.
 317         if (!tool->link_output().empty()) {
 318           link_output_file_ =
 319               SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 320                   this, tool, tool->link_output());
 321         }
 322         if (!tool->depend_output().empty()) {
 323           dependency_output_file_ =
 324               SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 325                   this, tool, tool->depend_output());
 326         }
 327       }
 328       break;
 329     case UNKNOWN:
 330     default:
 331       NOTREACHED();
 332   }
 333 }
 334
 335 bool Target::CheckVisibility(Err* err) const {
 336   for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
 337     if (!Visibility::CheckItemVisibility(this, iter.target(), err))
 338       return false;
 339   }
 340   return true;
 341 }
 342
 343 bool Target::CheckTestonly(Err* err) const {
 344   // If the current target is marked testonly, it can include both testonly
 345   // and non-testonly targets, so there's nothing to check.
 346   if (testonly())
 347     return true;
 348
 349   // Verify no deps have "testonly" set.
 350   for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
 351     if (iter.target()->testonly()) {
 352       *err = MakeTestOnlyError(this, iter.target());
 353       return false;
 354     }
 355   }
 356
 357   return true;
 358 }
 359
 360 bool Target::CheckNoNestedStaticLibs(Err* err) const {
 361   // If the current target is not a complete static library, it can depend on
 362   // static library targets with no problem.
 363   if (!(output_type() == Target::STATIC_LIBRARY && complete_static_lib()))
 364     return true;
 365
 366   // Verify no deps are static libraries.
 367   for (DepsIterator iter(this); !iter.done(); iter.Advance()) {
 368     if (iter.target()->output_type() == Target::STATIC_LIBRARY) {
 369       *err = MakeStaticLibDepsError(this, iter.target());
 370       return false;
 371     }
 372   }
 373
 374   // Verify no inherited libraries are static libraries.
 375   for (size_t i = 0; i < inherited_libraries().size(); ++i) {
 376     if (inherited_libraries()[i]->output_type() == Target::STATIC_LIBRARY) {
 377       *err = MakeStaticLibDepsError(this, inherited_libraries()[i]);
 378       return false;
 379     }
 380   }
 381   return true;
 382 }