blob: 646ec44af82e5747ce82b67a84d7306eaa984231 [file] [log] [blame]
// 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 "gn/ninja_copy_target_writer.h"
#include "base/strings/string_util.h"
#include "gn/general_tool.h"
#include "gn/ninja_utils.h"
#include "gn/output_file.h"
#include "gn/scheduler.h"
#include "gn/string_utils.h"
#include "gn/substitution_list.h"
#include "gn/substitution_writer.h"
#include "gn/target.h"
#include "gn/toolchain.h"
NinjaCopyTargetWriter::NinjaCopyTargetWriter(const Target* target,
std::ostream& out)
: NinjaTargetWriter(target, out) {}
NinjaCopyTargetWriter::~NinjaCopyTargetWriter() = default;
void NinjaCopyTargetWriter::Run() {
const Tool* copy_tool = target_->toolchain()->GetTool(GeneralTool::kGeneralToolCopy);
if (!copy_tool) {
nullptr, "Copy tool not defined",
"The toolchain " +
target_->toolchain()->label().GetUserVisibleName(false) +
"\n used by target " + target_->label().GetUserVisibleName(false) +
"\n doesn't define a \"copy\" tool."));
// General target-related substitutions needed by the copy tool.
std::vector<OutputFile> output_files;
out_ << std::endl;
WritePhonyForTarget(output_files, std::vector<OutputFile>());
void NinjaCopyTargetWriter::WriteCopyRules(
std::vector<OutputFile>* output_files) {
CHECK(target_->action_values().outputs().list().size() == 1);
const SubstitutionList& output_subst_list =
CHECK_EQ(1u, output_subst_list.list().size())
<< "Should have one entry exactly.";
const SubstitutionPattern& output_subst = output_subst_list.list()[0];
std::string tool_name = GetNinjaRulePrefixForToolchain(settings_) +
size_t num_output_uses = target_->sources().size();
std::vector<OutputFile> input_deps = WriteInputDepsPhonyAndGetDep(
std::vector<const Target*>(), num_output_uses);
std::vector<OutputFile> data_outs;
for (const auto& dep : target_->data_deps()) {
if (dep.ptr->dependency_output_file_or_phony())
// Note that we don't write implicit deps for copy steps. "copy" only
// depends on the output files themselves, rather than having includes
// (the possibility of generated #includes is the main reason for implicit
// dependencies).
// It would seem that specifying implicit dependencies on the deps of the
// copy command would still be harmless. But Chrome implements copy tools
// as hard links (much faster) which don't change the timestamp. If the
// ninja rule looks like this:
// output: copy input | foo.stamp
// The copy will not make a new timestamp on the output file, but the
// foo.stamp file generated from a previous step will have a new timestamp.
// The copy rule will therefore look out-of-date to Ninja and the rule will
// get rebuilt.
// If this copy is copying a generated file, not listing the implicit
// dependency will be fine as long as the input to the copy is properly
// listed as the output from the step that generated it.
// Moreover, doing this assumes that the copy step is always a simple
// locally run command, so there is no need for a toolchain dependency.
// Note that there is the need in some cases for order-only dependencies
// where a command might need to make sure something else runs before it runs
// to avoid conflicts. This is also needed for data_deps on a copy target.
// Such cases should be avoided where possible, but sometimes that's not
// possible.
for (const auto& input_file : target_->sources()) {
OutputFile output_file =
target_, target_->settings(), output_subst, input_file);
out_ << "build ";
path_output_.WriteFile(out_, output_file);
out_ << ": " << tool_name << " ";
path_output_.WriteFile(out_, input_file);
if (!input_deps.empty() || !data_outs.empty()) {
out_ << " ||";
path_output_.WriteFiles(out_, input_deps);
path_output_.WriteFiles(out_, data_outs);
out_ << std::endl;