blob: 869cac89487dd6a45ddf8a1538b226d197abe0a2 [file] [log] [blame]
// Copyright 2019 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_rust_binary_target_writer.h"
#include <sstream>
#include "tools/gn/deps_iterator.h"
#include "tools/gn/general_tool.h"
#include "tools/gn/ninja_target_command_util.h"
#include "tools/gn/ninja_utils.h"
#include "tools/gn/rust_substitution_type.h"
#include "tools/gn/substitution_writer.h"
#include "tools/gn/target.h"
namespace {
// Returns the proper escape options for writing compiler and linker flags.
EscapeOptions GetFlagOptions() {
EscapeOptions opts;
opts.mode = ESCAPE_NINJA_COMMAND;
return opts;
}
void WriteVar(const char* name,
const std::string& value,
EscapeOptions opts,
std::ostream& out) {
out << name << " = ";
EscapeStringToStream(out, value, opts);
out << std::endl;
}
void WriteCrateVars(const Target* target,
const Tool* tool,
EscapeOptions opts,
std::ostream& out) {
WriteVar(kRustSubstitutionCrateName.ninja_name,
target->rust_values().crate_name(), opts, out);
std::string crate_type;
switch (target->output_type()) {
case Target::EXECUTABLE:
crate_type = "bin";
break;
case Target::STATIC_LIBRARY:
crate_type = "staticlib";
break;
case Target::RUST_LIBRARY:
crate_type = "rlib";
break;
case Target::SHARED_LIBRARY:
switch (target->rust_values().crate_type()) {
case RustValues::CRATE_DYLIB:
crate_type = "dylib";
break;
case RustValues::CRATE_CDYLIB:
crate_type = "cdylib";
break;
case RustValues::CRATE_PROC_MACRO:
crate_type = "proc-macro";
break;
default:
NOTREACHED();
}
default:
NOTREACHED();
}
WriteVar(kRustSubstitutionCrateType.ninja_name, crate_type, opts, out);
if (!target->output_extension_set()) {
DCHECK(tool->AsRust());
WriteVar(kRustSubstitutionOutputExtension.ninja_name,
tool->AsRust()->rustc_output_extension(
target->output_type(), target->rust_values().crate_type()),
opts, out);
} else if (target->output_extension().empty()) {
WriteVar(kRustSubstitutionOutputExtension.ninja_name, "", opts, out);
} else {
WriteVar(kRustSubstitutionOutputExtension.ninja_name,
std::string(".") + target->output_extension(), opts, out);
}
if (target->output_type() == Target::RUST_LIBRARY ||
target->output_type() == Target::SHARED_LIBRARY)
WriteVar(kRustSubstitutionOutputPrefix.ninja_name, "lib", opts, out);
}
} // namespace
NinjaRustBinaryTargetWriter::NinjaRustBinaryTargetWriter(const Target* target,
std::ostream& out)
: NinjaBinaryTargetWriter(target, out),
tool_(target->toolchain()->GetToolForTargetFinalOutputAsRust(target)) {}
NinjaRustBinaryTargetWriter::~NinjaRustBinaryTargetWriter() = default;
// TODO(juliehockett): add inherited library support? and IsLinkable support?
// for c-cross-compat
void NinjaRustBinaryTargetWriter::Run() {
OutputFile input_dep = WriteInputsStampAndGetDep();
// 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. See
// the comment on NinjaCBinaryTargetWriter::Run for more detailed explanation.
size_t num_stamp_uses = target_->sources().size();
std::vector<OutputFile> order_only_deps = WriteInputDepsStampAndGetDep(
std::vector<const Target*>(), num_stamp_uses);
// Public rust_library deps go in a --extern rlibs, public non-rust deps go in
// -Ldependency rustdeps, and non-public source_sets get passed in as normal
// source files
UniqueVector<OutputFile> deps;
AddSourceSetFiles(target_, &deps);
if (target_->output_type() == Target::SOURCE_SET) {
WriteSharedVars(target_->toolchain()->substitution_bits());
WriteSourceSetStamp(deps.vector());
} else {
WriteCompilerVars();
UniqueVector<const Target*> linkable_deps;
UniqueVector<const Target*> non_linkable_deps;
GetDeps(&deps, &linkable_deps, &non_linkable_deps);
if (!input_dep.value().empty())
order_only_deps.push_back(input_dep);
std::vector<OutputFile> rustdeps;
for (const auto* non_linkable_dep : non_linkable_deps) {
order_only_deps.push_back(non_linkable_dep->dependency_output_file());
}
for (const auto* linkable_dep : linkable_deps) {
rustdeps.push_back(linkable_dep->dependency_output_file());
deps.push_back(linkable_dep->dependency_output_file());
}
std::vector<OutputFile> tool_outputs;
SubstitutionWriter::ApplyListToLinkerAsOutputFile(
target_, tool_, tool_->outputs(), &tool_outputs);
WriteCompilerBuildLine(target_->rust_values().crate_root(), deps.vector(),
order_only_deps, tool_->name(), tool_outputs);
WriteExterns();
WriteRustdeps(rustdeps);
WriteEdition();
}
}
void NinjaRustBinaryTargetWriter::WriteCompilerVars() {
const SubstitutionBits& subst = target_->toolchain()->substitution_bits();
EscapeOptions opts = GetFlagOptions();
WriteCrateVars(target_, tool_, opts, out_);
WriteOneFlag(target_, &kRustSubstitutionRustFlags, false,
RustTool::kRsToolRustc, &ConfigValues::rustflags, opts,
path_output_, out_);
WriteOneFlag(target_, &kRustSubstitutionRustEnv, false,
RustTool::kRsToolRustc, &ConfigValues::rustenv, opts,
path_output_, out_);
WriteSharedVars(subst);
}
void NinjaRustBinaryTargetWriter::WriteExterns() {
std::vector<const Target*> externs;
for (const auto& pair : target_->GetDeps(Target::DEPS_LINKED)) {
if (pair.ptr->output_type() == Target::RUST_LIBRARY) {
externs.push_back(pair.ptr);
}
}
if (externs.empty())
return;
out_ << " externs =";
for (const Target* ex : externs) {
out_ << " --extern ";
const auto& renamed_dep =
target_->rust_values().aliased_deps().find(ex->label());
if (renamed_dep != target_->rust_values().aliased_deps().end()) {
out_ << renamed_dep->second << "=";
} else {
out_ << std::string(ex->rust_values().crate_name()) << "=";
}
path_output_.WriteFile(out_, ex->dependency_output_file());
}
out_ << std::endl;
}
void NinjaRustBinaryTargetWriter::WriteRustdeps(
std::vector<OutputFile>& rustdeps) {
if (rustdeps.empty())
return;
out_ << " rustdeps =";
for (const auto& rustdep : rustdeps) {
out_ << " -Ldependency=";
path_output_.WriteDir(
out_, rustdep.AsSourceFile(settings_->build_settings()).GetDir(),
PathOutput::DIR_NO_LAST_SLASH);
}
out_ << std::endl;
}
void NinjaRustBinaryTargetWriter::WriteEdition() {
DCHECK(!target_->rust_values().edition().empty());
out_ << " edition = " << target_->rust_values().edition() << std::endl;
}