src/gn/ninja_binary_target_writer.cc - third_party/gn - Git at Google

 // 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_binary_target_writer.h"

 #include <sstream>

 #include "base/strings/string_util.h"
 #include "gn/config_values_extractors.h"
 #include "gn/deps_iterator.h"
 #include "gn/filesystem_utils.h"
 #include "gn/general_tool.h"
 #include "gn/ninja_c_binary_target_writer.h"
 #include "gn/ninja_rust_binary_target_writer.h"
 #include "gn/ninja_target_command_util.h"
 #include "gn/ninja_utils.h"
 #include "gn/settings.h"
 #include "gn/string_utils.h"
 #include "gn/substitution_writer.h"
 #include "gn/target.h"
 #include "gn/variables.h"

 namespace {

 // Returns the proper escape options for writing compiler and linker flags.
 EscapeOptions GetFlagOptions() {
   EscapeOptions opts;
   opts.mode = ESCAPE_NINJA_COMMAND;
   return opts;
 }

 }  // namespace

 NinjaBinaryTargetWriter::NinjaBinaryTargetWriter(const Target* target,
                                                  std::ostream& out)
     : NinjaTargetWriter(target, out),
       rule_prefix_(GetNinjaRulePrefixForToolchain(settings_)) {}

 NinjaBinaryTargetWriter::~NinjaBinaryTargetWriter() = default;

 void NinjaBinaryTargetWriter::Run() {
   if (target_->source_types_used().RustSourceUsed()) {
     NinjaRustBinaryTargetWriter writer(target_, out_);
     writer.Run();
     return;
   }

   NinjaCBinaryTargetWriter writer(target_, out_);
   writer.Run();
 }

 std::vector<OutputFile> NinjaBinaryTargetWriter::WriteInputsStampAndGetDep(
     size_t num_stamp_uses) const {
   CHECK(target_->toolchain()) << "Toolchain not set on target "
                               << target_->label().GetUserVisibleName(true);

   UniqueVector<const SourceFile*> inputs;
   for (ConfigValuesIterator iter(target_); !iter.done(); iter.Next()) {
     for (const auto& input : iter.cur().inputs()) {
       inputs.push_back(&input);
     }
   }

   if (inputs.size() == 0)
     return std::vector<OutputFile>();  // No inputs

   // If we only have one input, return it directly instead of writing a stamp
   // file for it.
   if (inputs.size() == 1) {
     return std::vector<OutputFile>{
       OutputFile(settings_->build_settings(), *inputs[0])};
   }

   std::vector<OutputFile> outs;
   for (const SourceFile* source : inputs)
     outs.push_back(OutputFile(settings_->build_settings(), *source));

   // If there are multiple inputs, but the stamp file would be referenced only
   // once, don't write it but depend on the inputs directly.
   if (num_stamp_uses == 1u)
     return outs;

   // Make a stamp file.
   OutputFile stamp_file =
       GetBuildDirForTargetAsOutputFile(target_, BuildDirType::OBJ);
   stamp_file.value().append(target_->label().name());
   stamp_file.value().append(".inputs.stamp");

   out_ << "build ";
   path_output_.WriteFile(out_, stamp_file);
   out_ << ": " << GetNinjaRulePrefixForToolchain(settings_)
        << GeneralTool::kGeneralToolStamp;

   // File inputs.
   for (const auto* input : inputs) {
     out_ << " ";
     path_output_.WriteFile(out_, *input);
   }

   out_ << std::endl;
   return {stamp_file};
 }

 void NinjaBinaryTargetWriter::WriteSourceSetStamp(
     const std::vector<OutputFile>& object_files) {
   // The stamp rule for source sets is generally not used, since targets that
   // depend on this will reference the object files directly. However, writing
   // this rule allows the user to type the name of the target and get a build
   // which can be convenient for development.
   ClassifiedDeps classified_deps = GetClassifiedDeps();

   // The classifier should never put extra object files in a source sets: any
   // source sets that we depend on should appear in our non-linkable deps
   // instead.
   DCHECK(classified_deps.extra_object_files.empty());

   std::vector<OutputFile> order_only_deps;
   for (auto* dep : classified_deps.non_linkable_deps)
     order_only_deps.push_back(dep->dependency_output_file());

   WriteStampForTarget(object_files, order_only_deps);
 }

 NinjaBinaryTargetWriter::ClassifiedDeps
 NinjaBinaryTargetWriter::GetClassifiedDeps() const {
   ClassifiedDeps classified_deps;

   // Normal public/private deps.
   for (const auto& pair : target_->GetDeps(Target::DEPS_LINKED)) {
     ClassifyDependency(pair.ptr, &classified_deps);
   }

   // Inherited libraries.
   for (auto* inherited_target : target_->inherited_libraries().GetOrdered()) {
     ClassifyDependency(inherited_target, &classified_deps);
   }

   // Data deps.
   for (const auto& data_dep_pair : target_->data_deps())
     classified_deps.non_linkable_deps.push_back(data_dep_pair.ptr);

   return classified_deps;
 }

 void NinjaBinaryTargetWriter::ClassifyDependency(
     const Target* dep,
     ClassifiedDeps* classified_deps) const {
   // Only the following types of outputs have libraries linked into them:
   //  EXECUTABLE
   //  SHARED_LIBRARY
   //  _complete_ STATIC_LIBRARY
   //
   // Child deps of intermediate static libraries get pushed up the
   // dependency tree until one of these is reached, and source sets
   // don't link at all.
   bool can_link_libs = target_->IsFinal();

   if (can_link_libs && dep->swift_values().builds_module())
     classified_deps->swiftmodule_deps.push_back(dep);

   if (target_->source_types_used().RustSourceUsed() &&
       (target_->output_type() == Target::RUST_LIBRARY ||
        target_->output_type() == Target::STATIC_LIBRARY) &&
       dep->IsLinkable()) {
     // Rust libraries and static libraries aren't final, but need to have the
     // link lines of all transitive deps specified.
     classified_deps->linkable_deps.push_back(dep);
   } else if (dep->output_type() == Target::SOURCE_SET ||
              // If a complete static library depends on an incomplete static
              // library, manually link in the object files of the dependent
              // library as if it were a source set. This avoids problems with
              // braindead tools such as ar which don't properly link dependent
              // static libraries.
              (target_->complete_static_lib() &&
               (dep->output_type() == Target::STATIC_LIBRARY &&
                !dep->complete_static_lib()))) {
     // Source sets have their object files linked into final targets
     // (shared libraries, executables, loadable modules, and complete static
     // libraries). Intermediate static libraries and other source sets
     // just forward the dependency, otherwise the files in the source
     // set can easily get linked more than once which will cause
     // multiple definition errors.
     if (can_link_libs)
       AddSourceSetFiles(dep, &classified_deps->extra_object_files);

     // Add the source set itself as a non-linkable dependency on the current
     // target. This will make sure that anything the source set's stamp file
     // depends on (like data deps) are also built before the current target
     // can be complete. Otherwise, these will be skipped since this target
     // will depend only on the source set's object files.
     classified_deps->non_linkable_deps.push_back(dep);
   } else if (target_->complete_static_lib() && dep->IsFinal()) {
     classified_deps->non_linkable_deps.push_back(dep);
   } else if (can_link_libs && dep->IsLinkable()) {
     classified_deps->linkable_deps.push_back(dep);
   } else if (dep->output_type() == Target::CREATE_BUNDLE &&
              dep->bundle_data().is_framework()) {
     classified_deps->framework_deps.push_back(dep);
   } else {
     classified_deps->non_linkable_deps.push_back(dep);
   }
 }

 void NinjaBinaryTargetWriter::AddSourceSetFiles(
     const Target* source_set,
     UniqueVector<OutputFile>* obj_files) const {
   std::vector<OutputFile> tool_outputs;  // Prevent allocation in loop.

   // Compute object files for all sources. Only link the first output from
   // the tool if there are more than one.
   for (const auto& source : source_set->sources()) {
     const char* tool_name = Tool::kToolNone;
     if (source_set->GetOutputFilesForSource(source, &tool_name, &tool_outputs))
       obj_files->push_back(tool_outputs[0]);
   }

   // Swift files may generate one object file per module or one per source file
   // depending on how the compiler is invoked (whole module optimization).
   if (source_set->source_types_used().SwiftSourceUsed()) {
     const Tool* tool = source_set->toolchain()->GetToolForSourceTypeAsC(
         SourceFile::SOURCE_SWIFT);

     std::vector<OutputFile> outputs;
     SubstitutionWriter::ApplyListToLinkerAsOutputFile(
         source_set, tool, tool->outputs(), &outputs);

     for (const OutputFile& output : outputs) {
       SourceFile output_as_source =
           output.AsSourceFile(source_set->settings()->build_settings());
       if (output_as_source.type() == SourceFile::SOURCE_O) {
         obj_files->push_back(output);
       }
     }
   }

   // Add MSVC precompiled header object files. GCC .gch files are not object
   // files so they are omitted.
   if (source_set->config_values().has_precompiled_headers()) {
     if (source_set->source_types_used().Get(SourceFile::SOURCE_C)) {
       const CTool* tool = source_set->toolchain()->GetToolAsC(CTool::kCToolCc);
       if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
         GetPCHOutputFiles(source_set, CTool::kCToolCc, &tool_outputs);
         obj_files->Append(tool_outputs.begin(), tool_outputs.end());
       }
     }
     if (source_set->source_types_used().Get(SourceFile::SOURCE_CPP)) {
       const CTool* tool = source_set->toolchain()->GetToolAsC(CTool::kCToolCxx);
       if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
         GetPCHOutputFiles(source_set, CTool::kCToolCxx, &tool_outputs);
         obj_files->Append(tool_outputs.begin(), tool_outputs.end());
       }
     }
     if (source_set->source_types_used().Get(SourceFile::SOURCE_M)) {
       const CTool* tool =
           source_set->toolchain()->GetToolAsC(CTool::kCToolObjC);
       if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
         GetPCHOutputFiles(source_set, CTool::kCToolObjC, &tool_outputs);
         obj_files->Append(tool_outputs.begin(), tool_outputs.end());
       }
     }
     if (source_set->source_types_used().Get(SourceFile::SOURCE_MM)) {
       const CTool* tool =
           source_set->toolchain()->GetToolAsC(CTool::kCToolObjCxx);
       if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
         GetPCHOutputFiles(source_set, CTool::kCToolObjCxx, &tool_outputs);
         obj_files->Append(tool_outputs.begin(), tool_outputs.end());
       }
     }
   }
 }

 void NinjaBinaryTargetWriter::WriteCompilerBuildLine(
     const std::vector<SourceFile>& sources,
     const std::vector<OutputFile>& extra_deps,
     const std::vector<OutputFile>& order_only_deps,
     const char* tool_name,
     const std::vector<OutputFile>& outputs) {
   out_ << "build";
   path_output_.WriteFiles(out_, outputs);

   out_ << ": " << rule_prefix_ << tool_name;
   path_output_.WriteFiles(out_, sources);

   if (!extra_deps.empty()) {
     out_ << " |";
     path_output_.WriteFiles(out_, extra_deps);
   }

   if (!order_only_deps.empty()) {
     out_ << " ||";
     path_output_.WriteFiles(out_, order_only_deps);
   }
   out_ << std::endl;
 }

 void NinjaBinaryTargetWriter::WriteLinkerFlags(
     std::ostream& out,
     const Tool* tool,
     const SourceFile* optional_def_file) {
   if (tool->AsC()) {
     // First the ldflags from the target and its config.
     RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags,
                                        GetFlagOptions(), out);
   }

   // Followed by library search paths that have been recursively pushed
   // through the dependency tree.
   const OrderedSet<SourceDir> all_lib_dirs = target_->all_lib_dirs();
   if (!all_lib_dirs.empty()) {
     // Since we're passing these on the command line to the linker and not
     // to Ninja, we need to do shell escaping.
     PathOutput lib_path_output(path_output_.current_dir(),
                                settings_->build_settings()->root_path_utf8(),
                                ESCAPE_NINJA_COMMAND);
     for (size_t i = 0; i < all_lib_dirs.size(); i++) {
       out << " " << tool->lib_dir_switch();
       lib_path_output.WriteDir(out, all_lib_dirs[i],
                                PathOutput::DIR_NO_LAST_SLASH);
     }
   }

   const auto& all_framework_dirs = target_->all_framework_dirs();
   if (!all_framework_dirs.empty()) {
     // Since we're passing these on the command line to the linker and not
     // to Ninja, we need to do shell escaping.
     PathOutput framework_path_output(
         path_output_.current_dir(),
         settings_->build_settings()->root_path_utf8(), ESCAPE_NINJA_COMMAND);
     for (size_t i = 0; i < all_framework_dirs.size(); i++) {
       out << " " << tool->framework_dir_switch();
       framework_path_output.WriteDir(out, all_framework_dirs[i],
                                      PathOutput::DIR_NO_LAST_SLASH);
     }
   }

   if (optional_def_file) {
     out_ << " /DEF:";
     path_output_.WriteFile(out, *optional_def_file);
   }
 }

 void NinjaBinaryTargetWriter::WriteLibs(std::ostream& out, const Tool* tool) {
   // Libraries that have been recursively pushed through the dependency tree.
   EscapeOptions lib_escape_opts;
   lib_escape_opts.mode = ESCAPE_NINJA_COMMAND;
   const OrderedSet<LibFile> all_libs = target_->all_libs();
   for (size_t i = 0; i < all_libs.size(); i++) {
     const LibFile& lib_file = all_libs[i];
     const std::string& lib_value = lib_file.value();
     if (lib_file.is_source_file()) {
       out << " " << tool->linker_arg();
       path_output_.WriteFile(out, lib_file.source_file());
     } else {
       out << " " << tool->lib_switch();
       EscapeStringToStream(out, lib_value, lib_escape_opts);
     }
   }
 }

 void NinjaBinaryTargetWriter::WriteFrameworks(std::ostream& out,
                                               const Tool* tool) {
   // Frameworks that have been recursively pushed through the dependency tree.
   FrameworksWriter writer(tool->framework_switch());
   const auto& all_frameworks = target_->all_frameworks();
   for (size_t i = 0; i < all_frameworks.size(); i++) {
     writer(all_frameworks[i], out);
   }

   FrameworksWriter weak_writer(tool->weak_framework_switch());
   const auto& all_weak_frameworks = target_->all_weak_frameworks();
   for (size_t i = 0; i < all_weak_frameworks.size(); i++) {
     weak_writer(all_weak_frameworks[i], out);
   }
 }

 void NinjaBinaryTargetWriter::WriteSwiftModules(
     std::ostream& out,
     const Tool* tool,
     const std::vector<OutputFile>& swiftmodules) {
   // Since we're passing these on the command line to the linker and not
   // to Ninja, we need to do shell escaping.
   PathOutput swiftmodule_path_output(
       path_output_.current_dir(), settings_->build_settings()->root_path_utf8(),
       ESCAPE_NINJA_COMMAND);

   for (const OutputFile& swiftmodule : swiftmodules) {
     out << " " << tool->swiftmodule_switch();
     swiftmodule_path_output.WriteFile(out, swiftmodule);
   }
 }
	// 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_binary_target_writer.h"

	#include <sstream>

	#include "base/strings/string_util.h"
	#include "gn/config_values_extractors.h"
	#include "gn/deps_iterator.h"
	#include "gn/filesystem_utils.h"
	#include "gn/general_tool.h"
	#include "gn/ninja_c_binary_target_writer.h"
	#include "gn/ninja_rust_binary_target_writer.h"
	#include "gn/ninja_target_command_util.h"
	#include "gn/ninja_utils.h"
	#include "gn/settings.h"
	#include "gn/string_utils.h"
	#include "gn/substitution_writer.h"
	#include "gn/target.h"
	#include "gn/variables.h"

	namespace {

	// Returns the proper escape options for writing compiler and linker flags.
	EscapeOptions GetFlagOptions() {
	EscapeOptions opts;
	opts.mode = ESCAPE_NINJA_COMMAND;
	return opts;
	}

	} // namespace

	NinjaBinaryTargetWriter::NinjaBinaryTargetWriter(const Target* target,
	std::ostream& out)
	: NinjaTargetWriter(target, out),
	rule_prefix_(GetNinjaRulePrefixForToolchain(settings_)) {}

	NinjaBinaryTargetWriter::~NinjaBinaryTargetWriter() = default;

	void NinjaBinaryTargetWriter::Run() {
	if (target_->source_types_used().RustSourceUsed()) {
	NinjaRustBinaryTargetWriter writer(target_, out_);
	writer.Run();
	return;
	}

	NinjaCBinaryTargetWriter writer(target_, out_);
	writer.Run();
	}

	std::vector<OutputFile> NinjaBinaryTargetWriter::WriteInputsStampAndGetDep(
	size_t num_stamp_uses) const {
	CHECK(target_->toolchain()) << "Toolchain not set on target "
	<< target_->label().GetUserVisibleName(true);

	UniqueVector<const SourceFile*> inputs;
	for (ConfigValuesIterator iter(target_); !iter.done(); iter.Next()) {
	for (const auto& input : iter.cur().inputs()) {
	inputs.push_back(&input);
	}
	}

	if (inputs.size() == 0)
	return std::vector<OutputFile>(); // No inputs

	// If we only have one input, return it directly instead of writing a stamp
	// file for it.
	if (inputs.size() == 1) {
	return std::vector<OutputFile>{
	OutputFile(settings_->build_settings(), *inputs[0])};
	}

	std::vector<OutputFile> outs;
	for (const SourceFile* source : inputs)
	outs.push_back(OutputFile(settings_->build_settings(), *source));

	// If there are multiple inputs, but the stamp file would be referenced only
	// once, don't write it but depend on the inputs directly.
	if (num_stamp_uses == 1u)
	return outs;

	// Make a stamp file.
	OutputFile stamp_file =
	GetBuildDirForTargetAsOutputFile(target_, BuildDirType::OBJ);
	stamp_file.value().append(target_->label().name());
	stamp_file.value().append(".inputs.stamp");

	out_ << "build ";
	path_output_.WriteFile(out_, stamp_file);
	out_ << ": " << GetNinjaRulePrefixForToolchain(settings_)
	<< GeneralTool::kGeneralToolStamp;

	// File inputs.
	for (const auto* input : inputs) {
	out_ << " ";
	path_output_.WriteFile(out_, *input);
	}

	out_ << std::endl;
	return {stamp_file};
	}

	void NinjaBinaryTargetWriter::WriteSourceSetStamp(
	const std::vector<OutputFile>& object_files) {
	// The stamp rule for source sets is generally not used, since targets that
	// depend on this will reference the object files directly. However, writing
	// this rule allows the user to type the name of the target and get a build
	// which can be convenient for development.
	ClassifiedDeps classified_deps = GetClassifiedDeps();

	// The classifier should never put extra object files in a source sets: any
	// source sets that we depend on should appear in our non-linkable deps
	// instead.
	DCHECK(classified_deps.extra_object_files.empty());

	std::vector<OutputFile> order_only_deps;
	for (auto* dep : classified_deps.non_linkable_deps)
	order_only_deps.push_back(dep->dependency_output_file());

	WriteStampForTarget(object_files, order_only_deps);
	}

	NinjaBinaryTargetWriter::ClassifiedDeps
	NinjaBinaryTargetWriter::GetClassifiedDeps() const {
	ClassifiedDeps classified_deps;

	// Normal public/private deps.
	for (const auto& pair : target_->GetDeps(Target::DEPS_LINKED)) {
	ClassifyDependency(pair.ptr, &classified_deps);
	}

	// Inherited libraries.
	for (auto* inherited_target : target_->inherited_libraries().GetOrdered()) {
	ClassifyDependency(inherited_target, &classified_deps);
	}

	// Data deps.
	for (const auto& data_dep_pair : target_->data_deps())
	classified_deps.non_linkable_deps.push_back(data_dep_pair.ptr);

	return classified_deps;
	}

	void NinjaBinaryTargetWriter::ClassifyDependency(
	const Target* dep,
	ClassifiedDeps* classified_deps) const {
	// Only the following types of outputs have libraries linked into them:
	// EXECUTABLE
	// SHARED_LIBRARY
	// _complete_ STATIC_LIBRARY
	//
	// Child deps of intermediate static libraries get pushed up the
	// dependency tree until one of these is reached, and source sets
	// don't link at all.
	bool can_link_libs = target_->IsFinal();

	if (can_link_libs && dep->swift_values().builds_module())
	classified_deps->swiftmodule_deps.push_back(dep);

	if (target_->source_types_used().RustSourceUsed() &&
	(target_->output_type() == Target::RUST_LIBRARY \|\|
	target_->output_type() == Target::STATIC_LIBRARY) &&
	dep->IsLinkable()) {
	// Rust libraries and static libraries aren't final, but need to have the
	// link lines of all transitive deps specified.
	classified_deps->linkable_deps.push_back(dep);
	} else if (dep->output_type() == Target::SOURCE_SET \|\|
	// If a complete static library depends on an incomplete static
	// library, manually link in the object files of the dependent
	// library as if it were a source set. This avoids problems with
	// braindead tools such as ar which don't properly link dependent
	// static libraries.
	(target_->complete_static_lib() &&
	(dep->output_type() == Target::STATIC_LIBRARY &&
	!dep->complete_static_lib()))) {
	// Source sets have their object files linked into final targets
	// (shared libraries, executables, loadable modules, and complete static
	// libraries). Intermediate static libraries and other source sets
	// just forward the dependency, otherwise the files in the source
	// set can easily get linked more than once which will cause
	// multiple definition errors.
	if (can_link_libs)
	AddSourceSetFiles(dep, &classified_deps->extra_object_files);

	// Add the source set itself as a non-linkable dependency on the current
	// target. This will make sure that anything the source set's stamp file
	// depends on (like data deps) are also built before the current target
	// can be complete. Otherwise, these will be skipped since this target
	// will depend only on the source set's object files.
	classified_deps->non_linkable_deps.push_back(dep);
	} else if (target_->complete_static_lib() && dep->IsFinal()) {
	classified_deps->non_linkable_deps.push_back(dep);
	} else if (can_link_libs && dep->IsLinkable()) {
	classified_deps->linkable_deps.push_back(dep);
	} else if (dep->output_type() == Target::CREATE_BUNDLE &&
	dep->bundle_data().is_framework()) {
	classified_deps->framework_deps.push_back(dep);
	} else {
	classified_deps->non_linkable_deps.push_back(dep);
	}
	}

	void NinjaBinaryTargetWriter::AddSourceSetFiles(
	const Target* source_set,
	UniqueVector<OutputFile>* obj_files) const {
	std::vector<OutputFile> tool_outputs; // Prevent allocation in loop.

	// Compute object files for all sources. Only link the first output from
	// the tool if there are more than one.
	for (const auto& source : source_set->sources()) {
	const char* tool_name = Tool::kToolNone;
	if (source_set->GetOutputFilesForSource(source, &tool_name, &tool_outputs))
	obj_files->push_back(tool_outputs[0]);
	}

	// Swift files may generate one object file per module or one per source file
	// depending on how the compiler is invoked (whole module optimization).
	if (source_set->source_types_used().SwiftSourceUsed()) {
	const Tool* tool = source_set->toolchain()->GetToolForSourceTypeAsC(
	SourceFile::SOURCE_SWIFT);

	std::vector<OutputFile> outputs;
	SubstitutionWriter::ApplyListToLinkerAsOutputFile(
	source_set, tool, tool->outputs(), &outputs);

	for (const OutputFile& output : outputs) {
	SourceFile output_as_source =
	output.AsSourceFile(source_set->settings()->build_settings());
	if (output_as_source.type() == SourceFile::SOURCE_O) {
	obj_files->push_back(output);
	}
	}
	}

	// Add MSVC precompiled header object files. GCC .gch files are not object
	// files so they are omitted.
	if (source_set->config_values().has_precompiled_headers()) {
	if (source_set->source_types_used().Get(SourceFile::SOURCE_C)) {
	const CTool* tool = source_set->toolchain()->GetToolAsC(CTool::kCToolCc);
	if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
	GetPCHOutputFiles(source_set, CTool::kCToolCc, &tool_outputs);
	obj_files->Append(tool_outputs.begin(), tool_outputs.end());
	}
	}
	if (source_set->source_types_used().Get(SourceFile::SOURCE_CPP)) {
	const CTool* tool = source_set->toolchain()->GetToolAsC(CTool::kCToolCxx);
	if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
	GetPCHOutputFiles(source_set, CTool::kCToolCxx, &tool_outputs);
	obj_files->Append(tool_outputs.begin(), tool_outputs.end());
	}
	}
	if (source_set->source_types_used().Get(SourceFile::SOURCE_M)) {
	const CTool* tool =
	source_set->toolchain()->GetToolAsC(CTool::kCToolObjC);
	if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
	GetPCHOutputFiles(source_set, CTool::kCToolObjC, &tool_outputs);
	obj_files->Append(tool_outputs.begin(), tool_outputs.end());
	}
	}
	if (source_set->source_types_used().Get(SourceFile::SOURCE_MM)) {
	const CTool* tool =
	source_set->toolchain()->GetToolAsC(CTool::kCToolObjCxx);
	if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
	GetPCHOutputFiles(source_set, CTool::kCToolObjCxx, &tool_outputs);
	obj_files->Append(tool_outputs.begin(), tool_outputs.end());
	}
	}
	}
	}

	void NinjaBinaryTargetWriter::WriteCompilerBuildLine(
	const std::vector<SourceFile>& sources,
	const std::vector<OutputFile>& extra_deps,
	const std::vector<OutputFile>& order_only_deps,
	const char* tool_name,
	const std::vector<OutputFile>& outputs) {
	out_ << "build";
	path_output_.WriteFiles(out_, outputs);

	out_ << ": " << rule_prefix_ << tool_name;
	path_output_.WriteFiles(out_, sources);

	if (!extra_deps.empty()) {
	out_ << " \|";
	path_output_.WriteFiles(out_, extra_deps);
	}

	if (!order_only_deps.empty()) {
	out_ << " \|\|";
	path_output_.WriteFiles(out_, order_only_deps);
	}
	out_ << std::endl;
	}

	void NinjaBinaryTargetWriter::WriteLinkerFlags(
	std::ostream& out,
	const Tool* tool,
	const SourceFile* optional_def_file) {
	if (tool->AsC()) {
	// First the ldflags from the target and its config.
	RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags,
	GetFlagOptions(), out);
	}

	// Followed by library search paths that have been recursively pushed
	// through the dependency tree.
	const OrderedSet<SourceDir> all_lib_dirs = target_->all_lib_dirs();
	if (!all_lib_dirs.empty()) {
	// Since we're passing these on the command line to the linker and not
	// to Ninja, we need to do shell escaping.
	PathOutput lib_path_output(path_output_.current_dir(),
	settings_->build_settings()->root_path_utf8(),
	ESCAPE_NINJA_COMMAND);
	for (size_t i = 0; i < all_lib_dirs.size(); i++) {
	out << " " << tool->lib_dir_switch();
	lib_path_output.WriteDir(out, all_lib_dirs[i],
	PathOutput::DIR_NO_LAST_SLASH);
	}
	}

	const auto& all_framework_dirs = target_->all_framework_dirs();
	if (!all_framework_dirs.empty()) {
	// Since we're passing these on the command line to the linker and not
	// to Ninja, we need to do shell escaping.
	PathOutput framework_path_output(
	path_output_.current_dir(),
	settings_->build_settings()->root_path_utf8(), ESCAPE_NINJA_COMMAND);
	for (size_t i = 0; i < all_framework_dirs.size(); i++) {
	out << " " << tool->framework_dir_switch();
	framework_path_output.WriteDir(out, all_framework_dirs[i],
	PathOutput::DIR_NO_LAST_SLASH);
	}
	}

	if (optional_def_file) {
	out_ << " /DEF:";
	path_output_.WriteFile(out, *optional_def_file);
	}
	}

	void NinjaBinaryTargetWriter::WriteLibs(std::ostream& out, const Tool* tool) {
	// Libraries that have been recursively pushed through the dependency tree.
	EscapeOptions lib_escape_opts;
	lib_escape_opts.mode = ESCAPE_NINJA_COMMAND;
	const OrderedSet<LibFile> all_libs = target_->all_libs();
	for (size_t i = 0; i < all_libs.size(); i++) {
	const LibFile& lib_file = all_libs[i];
	const std::string& lib_value = lib_file.value();
	if (lib_file.is_source_file()) {
	out << " " << tool->linker_arg();
	path_output_.WriteFile(out, lib_file.source_file());
	} else {
	out << " " << tool->lib_switch();
	EscapeStringToStream(out, lib_value, lib_escape_opts);
	}
	}
	}

	void NinjaBinaryTargetWriter::WriteFrameworks(std::ostream& out,
	const Tool* tool) {
	// Frameworks that have been recursively pushed through the dependency tree.
	FrameworksWriter writer(tool->framework_switch());
	const auto& all_frameworks = target_->all_frameworks();
	for (size_t i = 0; i < all_frameworks.size(); i++) {
	writer(all_frameworks[i], out);
	}

	FrameworksWriter weak_writer(tool->weak_framework_switch());
	const auto& all_weak_frameworks = target_->all_weak_frameworks();
	for (size_t i = 0; i < all_weak_frameworks.size(); i++) {
	weak_writer(all_weak_frameworks[i], out);
	}
	}

	void NinjaBinaryTargetWriter::WriteSwiftModules(
	std::ostream& out,
	const Tool* tool,
	const std::vector<OutputFile>& swiftmodules) {
	// Since we're passing these on the command line to the linker and not
	// to Ninja, we need to do shell escaping.
	PathOutput swiftmodule_path_output(
	path_output_.current_dir(), settings_->build_settings()->root_path_utf8(),
	ESCAPE_NINJA_COMMAND);

	for (const OutputFile& swiftmodule : swiftmodules) {
	out << " " << tool->swiftmodule_switch();
	swiftmodule_path_output.WriteFile(out, swiftmodule);
	}
	}