CMake/Source/cmNinjaTargetGenerator.cxx

1084 lines
39 KiB
C++
Raw Normal View History

2011-11-11 09:00:49 +04:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2011 Peter Collingbourne <peter@pcc.me.uk>
Copyright 2011 Nicolas Despres <nicolas.despres@gmail.com>
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmNinjaTargetGenerator.h"
#include "cmAlgorithms.h"
#include "cmComputeLinkInformation.h"
#include "cmCustomCommandGenerator.h"
2011-11-11 09:00:49 +04:00
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalNinjaGenerator.h"
#include "cmLocalGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
2011-11-11 09:00:49 +04:00
#include "cmNinjaNormalTargetGenerator.h"
#include "cmNinjaUtilityTargetGenerator.h"
#include "cmOutputConverter.h"
2011-11-11 09:00:49 +04:00
#include "cmSourceFile.h"
#include "cmState.h"
#include "cmSystemTools.h"
#include "cmake.h"
2011-11-11 09:00:49 +04:00
#include "cm_jsoncpp_writer.h"
2011-11-11 09:00:49 +04:00
#include <algorithm>
#include <iterator>
#include <map>
#include <sstream>
#include <string.h>
2011-11-11 09:00:49 +04:00
cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
2011-11-11 09:00:49 +04:00
{
switch (target->GetType()) {
case cmState::EXECUTABLE:
case cmState::SHARED_LIBRARY:
case cmState::STATIC_LIBRARY:
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
return new cmNinjaNormalTargetGenerator(target);
case cmState::UTILITY:
case cmState::GLOBAL_TARGET:
return new cmNinjaUtilityTargetGenerator(target);
default:
2016-06-27 23:44:16 +03:00
return CM_NULLPTR;
}
2011-11-11 09:00:49 +04:00
}
cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
: cmCommonTargetGenerator(target)
2016-06-27 23:44:16 +03:00
, MacOSXContentGenerator(CM_NULLPTR)
, OSXBundleGenerator(CM_NULLPTR)
, MacContentFolders()
, LocalGenerator(
static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator()))
, Objects()
2011-11-11 09:00:49 +04:00
{
2012-07-18 14:17:39 +04:00
MacOSXContentGenerator = new MacOSXContentGeneratorType(this);
2011-11-11 09:00:49 +04:00
}
cmNinjaTargetGenerator::~cmNinjaTargetGenerator()
{
2012-07-21 21:52:17 +04:00
delete this->MacOSXContentGenerator;
2011-11-11 09:00:49 +04:00
}
cmGeneratedFileStream& cmNinjaTargetGenerator::GetBuildFileStream() const
{
return *this->GetGlobalGenerator()->GetBuildFileStream();
}
cmGeneratedFileStream& cmNinjaTargetGenerator::GetRulesFileStream() const
{
return *this->GetGlobalGenerator()->GetRulesFileStream();
}
cmGlobalNinjaGenerator* cmNinjaTargetGenerator::GetGlobalGenerator() const
{
return this->LocalGenerator->GetGlobalNinjaGenerator();
}
std::string cmNinjaTargetGenerator::LanguageCompilerRule(
const std::string& lang) const
{
return lang + "_COMPILER__" +
2015-10-16 21:09:43 +03:00
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName());
}
std::string cmNinjaTargetGenerator::LanguagePreprocessRule(
std::string const& lang) const
{
return lang + "_PREPROCESS__" +
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName());
}
bool cmNinjaTargetGenerator::NeedExplicitPreprocessing(
std::string const& lang) const
{
return lang == "Fortran";
}
std::string cmNinjaTargetGenerator::LanguageDyndepRule(
const std::string& lang) const
{
return lang + "_DYNDEP__" +
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName());
}
bool cmNinjaTargetGenerator::NeedDyndep(std::string const& lang) const
{
return lang == "Fortran";
}
std::string cmNinjaTargetGenerator::OrderDependsTargetForTarget()
{
return "cmake_order_depends_target_" + this->GetTargetName();
}
2011-11-11 09:00:49 +04:00
// TODO: Most of the code is picked up from
// void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink),
// void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
// Refactor it.
std::string cmNinjaTargetGenerator::ComputeFlagsForObject(
cmSourceFile const* source, const std::string& language)
2011-11-11 09:00:49 +04:00
{
std::string flags = this->GetFlags(language);
// Add Fortran format flags.
if (language == "Fortran") {
this->AppendFortranFormatFlags(flags, *source);
}
// Add source file specific flags.
this->LocalGenerator->AppendFlags(flags,
source->GetProperty("COMPILE_FLAGS"));
2011-11-11 09:00:49 +04:00
return flags;
}
void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
std::string const& language)
{
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
language, this->GetConfigName());
// Add include directory flags.
std::string includeFlags = this->LocalGenerator->GetIncludeFlags(
includes, this->GeneratorTarget, language,
language == "RC", // full include paths for RC needed by cmcldeps
false, this->GetConfigName());
if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
std::replace(includeFlags.begin(), includeFlags.end(), '\\', '/');
}
this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
}
bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const
{
return strcmp(this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" +
lang),
"msvc") == 0;
}
2011-11-11 09:00:49 +04:00
// TODO: Refactor with
// void cmMakefileTargetGenerator::WriteTargetLanguageFlags().
std::string cmNinjaTargetGenerator::ComputeDefines(cmSourceFile const* source,
const std::string& language)
2011-11-11 09:00:49 +04:00
{
std::set<std::string> defines;
this->LocalGenerator->AppendDefines(
defines, source->GetProperty("COMPILE_DEFINITIONS"));
2011-11-11 09:00:49 +04:00
{
std::string defPropName = "COMPILE_DEFINITIONS_";
defPropName += cmSystemTools::UpperCase(this->GetConfigName());
this->LocalGenerator->AppendDefines(defines,
source->GetProperty(defPropName));
2011-11-11 09:00:49 +04:00
}
std::string definesString = this->GetDefines(language);
this->LocalGenerator->JoinDefines(defines, definesString, language);
return definesString;
2011-11-11 09:00:49 +04:00
}
cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
{
// Static libraries never depend on other targets for linking.
if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
this->GeneratorTarget->GetType() == cmState::OBJECT_LIBRARY) {
2011-11-11 09:00:49 +04:00
return cmNinjaDeps();
}
2011-11-11 09:00:49 +04:00
cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(this->GetConfigName());
if (!cli) {
2011-11-11 09:00:49 +04:00
return cmNinjaDeps();
}
2011-11-11 09:00:49 +04:00
const std::vector<std::string>& deps = cli->GetDepends();
2011-11-11 09:00:49 +04:00
cmNinjaDeps result(deps.size());
std::transform(deps.begin(), deps.end(), result.begin(), MapToNinjaPath());
2012-03-07 02:41:40 +04:00
// Add a dependency on the link definitions file, if any.
if (this->ModuleDefinitionFile) {
result.push_back(
this->ConvertToNinjaPath(this->ModuleDefinitionFile->GetFullPath()));
}
2012-03-07 02:41:40 +04:00
// Add a dependency on user-specified manifest files, if any.
std::vector<cmSourceFile const*> manifest_srcs;
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
mi != manifest_srcs.end(); ++mi) {
result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath()));
}
// Add user-specified dependencies.
if (const char* linkDepends =
this->GeneratorTarget->GetProperty("LINK_DEPENDS")) {
std::vector<std::string> linkDeps;
cmSystemTools::ExpandListArgument(linkDepends, linkDeps);
std::transform(linkDeps.begin(), linkDeps.end(),
std::back_inserter(result), MapToNinjaPath());
}
2011-11-11 09:00:49 +04:00
return result;
}
std::string cmNinjaTargetGenerator::GetSourceFilePath(
cmSourceFile const* source) const
2011-11-11 09:00:49 +04:00
{
return ConvertToNinjaPath(source->GetFullPath());
2011-11-11 09:00:49 +04:00
}
std::string cmNinjaTargetGenerator::GetObjectFilePath(
cmSourceFile const* source) const
2011-11-11 09:00:49 +04:00
{
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
if (!path.empty()) {
2011-11-11 09:00:49 +04:00
path += "/";
}
std::string const& objectName = this->GeneratorTarget->GetObjectName(source);
path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
path += "/";
path += objectName;
2011-11-11 09:00:49 +04:00
return path;
}
std::string cmNinjaTargetGenerator::GetPreprocessedFilePath(
cmSourceFile const* source) const
{
// Choose an extension to compile already-preprocessed source.
std::string ppExt = source->GetExtension();
if (cmHasLiteralPrefix(ppExt, "F")) {
// Some Fortran compilers automatically enable preprocessing for
// upper-case extensions. Since the source is already preprocessed,
// use a lower-case extension.
ppExt = cmSystemTools::LowerCase(ppExt);
}
if (ppExt == "fpp") {
// Some Fortran compilers automatically enable preprocessing for
// the ".fpp" extension. Since the source is already preprocessed,
// use the ".f" extension.
ppExt = "f";
}
// Take the object file name and replace the extension.
std::string const& objName = this->GeneratorTarget->GetObjectName(source);
std::string const& objExt =
this->GetGlobalGenerator()->GetLanguageOutputExtension(*source);
assert(objName.size() >= objExt.size());
std::string const ppName =
objName.substr(0, objName.size() - objExt.size()) + "-pp." + ppExt;
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
if (!path.empty())
path += "/";
path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
path += "/";
path += ppName;
return path;
}
std::string cmNinjaTargetGenerator::GetDyndepFilePath(
std::string const& lang) const
{
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
if (!path.empty())
path += "/";
path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
path += "/";
path += lang;
path += ".dd";
return path;
}
std::string cmNinjaTargetGenerator::GetTargetDependInfoPath(
std::string const& lang) const
{
std::string path = this->Makefile->GetCurrentBinaryDirectory();
path += "/";
path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
path += "/" + lang + "DependInfo.json";
return path;
}
2011-11-11 09:00:49 +04:00
std::string cmNinjaTargetGenerator::GetTargetOutputDir() const
{
std::string dir = this->GeneratorTarget->GetDirectory(this->GetConfigName());
return ConvertToNinjaPath(dir);
2011-11-11 09:00:49 +04:00
}
std::string cmNinjaTargetGenerator::GetTargetFilePath(
const std::string& name) const
2011-11-11 09:00:49 +04:00
{
std::string path = this->GetTargetOutputDir();
if (path.empty() || path == ".") {
2011-11-11 09:00:49 +04:00
return name;
}
2011-11-11 09:00:49 +04:00
path += "/";
path += name;
return path;
}
std::string cmNinjaTargetGenerator::GetTargetName() const
{
2015-10-16 21:09:43 +03:00
return this->GeneratorTarget->GetName();
2011-11-11 09:00:49 +04:00
}
bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const
{
cmMakefile* mf = this->GetMakefile();
if (mf->GetDefinition("MSVC_C_ARCHITECTURE_ID") ||
mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID")) {
std::string pdbPath;
std::string compilePdbPath;
if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
pdbPath = this->GeneratorTarget->GetPDBDirectory(this->GetConfigName());
pdbPath += "/";
pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName());
}
if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
compilePdbPath =
this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
if (compilePdbPath.empty()) {
compilePdbPath = this->GeneratorTarget->GetSupportDirectory() + "/";
}
}
vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
ConvertToNinjaPath(pdbPath), cmOutputConverter::SHELL);
vars["TARGET_COMPILE_PDB"] =
this->GetLocalGenerator()->ConvertToOutputFormat(
ConvertToNinjaPath(compilePdbPath), cmOutputConverter::SHELL);
EnsureParentDirectoryExists(pdbPath);
EnsureParentDirectoryExists(compilePdbPath);
return true;
}
return false;
}
void cmNinjaTargetGenerator::WriteLanguageRules(const std::string& language)
2011-11-11 09:00:49 +04:00
{
#ifdef NINJA_GEN_VERBOSE_FILES
this->GetRulesFileStream() << "# Rules for language " << language << "\n\n";
#endif
2011-11-11 09:00:49 +04:00
this->WriteCompileRule(language);
}
void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
2011-11-11 09:00:49 +04:00
{
cmLocalGenerator::RuleVariables vars;
vars.RuleLauncher = "RULE_LAUNCH_COMPILE";
vars.CMTarget = this->GetGeneratorTarget();
2011-11-11 09:00:49 +04:00
vars.Language = lang.c_str();
vars.Source = "$IN_ABS";
2011-11-11 09:00:49 +04:00
vars.Object = "$out";
vars.Defines = "$DEFINES";
vars.Includes = "$INCLUDES";
vars.TargetPDB = "$TARGET_PDB";
vars.TargetCompilePDB = "$TARGET_COMPILE_PDB";
vars.ObjectDir = "$OBJECT_DIR";
vars.ObjectFileDir = "$OBJECT_FILE_DIR";
// For some cases we do an explicit preprocessor invocation.
bool const explicitPP = this->NeedExplicitPreprocessing(lang);
bool const needDyndep = this->NeedDyndep(lang);
cmMakefile* mf = this->GetMakefile();
std::string flags = "$FLAGS";
std::string rspfile;
std::string rspcontent;
std::string responseFlag;
if (lang != "RC" && this->ForceResponseFile()) {
rspfile = "$RSP_FILE";
responseFlag = "@" + rspfile;
rspcontent = " $DEFINES $INCLUDES $FLAGS";
flags = responseFlag;
vars.Defines = "";
vars.Includes = "";
}
// Tell ninja dependency format so all deps can be loaded into a database
std::string deptype;
std::string depfile;
std::string cldeps;
if (explicitPP) {
// The explicit preprocessing step will handle dependency scanning.
} else if (this->NeedDepTypeMSVC(lang)) {
deptype = "msvc";
depfile = "";
flags += " /showIncludes";
} else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_" + lang)) {
// For the MS resource compiler we need cmcldeps, but skip dependencies
// for source-file try_compile cases because they are always fresh.
if (!mf->GetIsSourceFileTryCompile()) {
deptype = "gcc";
depfile = "$DEP_FILE";
const std::string cl = mf->GetDefinition("CMAKE_C_COMPILER")
? mf->GetSafeDefinition("CMAKE_C_COMPILER")
: mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
cldeps = "\"";
cldeps += cmSystemTools::GetCMClDepsCommand();
cldeps += "\" " + lang + " $in \"$DEP_FILE\" $out \"";
cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
cldeps += "\" \"" + cl + "\" ";
}
} else {
deptype = "gcc";
const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
if (langdeptype) {
deptype = langdeptype;
}
depfile = "$DEP_FILE";
const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
std::string depfileFlags = mf->GetSafeDefinition(flagsName);
if (!depfileFlags.empty()) {
2013-11-04 16:18:47 +04:00
cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>", "$out");
2013-11-04 16:18:47 +04:00
cmSystemTools::ReplaceString(depfileFlags, "<CMAKE_C_COMPILER>",
mf->GetDefinition("CMAKE_C_COMPILER"));
flags += " " + depfileFlags;
}
}
2011-11-11 09:00:49 +04:00
vars.Flags = flags.c_str();
vars.DependencyFile = depfile.c_str();
2012-03-07 02:41:40 +04:00
std::string const tdi = this->GetLocalGenerator()->ConvertToOutputFormat(
ConvertToNinjaPath(this->GetTargetDependInfoPath(lang)),
cmLocalGenerator::SHELL);
if (explicitPP) {
// Lookup the explicit preprocessing rule.
std::string const ppVar = "CMAKE_" + lang + "_PREPROCESS_SOURCE";
std::string const ppCmd =
this->GetMakefile()->GetRequiredDefinition(ppVar);
// Explicit preprocessing always uses a depfile.
std::string const ppDeptype = ""; // no deps= for multiple outputs
std::string const ppDepfile = "$DEP_FILE";
cmLocalGenerator::RuleVariables ppVars;
ppVars.RuleLauncher = vars.RuleLauncher;
ppVars.CMTarget = vars.CMTarget;
ppVars.Language = vars.Language;
ppVars.Object = "$out"; // for RULE_LAUNCH_COMPILE
ppVars.PreprocessedSource = "$out";
ppVars.DependencyFile = ppDepfile.c_str();
// Preprocessing uses the original source,
// compilation uses preprocessed output.
ppVars.Source = vars.Source;
vars.Source = "$in";
// Preprocessing and compilation use the same flags.
ppVars.Flags = vars.Flags;
// Move preprocessor definitions to the preprocessor rule.
ppVars.Defines = vars.Defines;
vars.Defines = "";
// Copy include directories to the preprocessor rule. The Fortran
// compilation rule still needs them for the INCLUDE directive.
ppVars.Includes = vars.Includes;
// Rule for preprocessing source file.
std::vector<std::string> ppCmds;
cmSystemTools::ExpandListArgument(ppCmd, ppCmds);
for (std::vector<std::string>::iterator i = ppCmds.begin();
i != ppCmds.end(); ++i) {
this->GetLocalGenerator()->ExpandRuleVariables(*i, ppVars);
}
// Run CMake dependency scanner on preprocessed output.
std::string const cmake = this->GetLocalGenerator()->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
ppCmds.push_back(
cmake + " -E cmake_ninja_depends"
" --tdi=" +
tdi + " --pp=$out"
" --dep=$DEP_FILE" +
(needDyndep ? " --obj=$OBJ_FILE --ddi=$DYNDEP_INTERMEDIATE_FILE" : ""));
std::string const ppCmdLine =
this->GetLocalGenerator()->BuildCommandLine(ppCmds);
// Write the rule for preprocessing file of the given language.
std::ostringstream ppComment;
ppComment << "Rule for preprocessing " << lang << " files.";
std::ostringstream ppDesc;
ppDesc << "Building " << lang << " preprocessed $out";
this->GetGlobalGenerator()->AddRule(this->LanguagePreprocessRule(lang),
ppCmdLine, ppDesc.str(),
ppComment.str(), ppDepfile, ppDeptype,
/*rspfile*/ "",
/*rspcontent*/ "",
/*restat*/ "",
/*generator*/ false);
}
if (needDyndep) {
// Write the rule for ninja dyndep file generation.
std::vector<std::string> ddCmds;
// Run CMake dependency scanner on preprocessed output.
std::string const cmake = this->GetLocalGenerator()->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
ddCmds.push_back(cmake + " -E cmake_ninja_dyndep"
" --tdi=" +
tdi + " --dd=$out"
" $in");
std::string const ddCmdLine =
this->GetLocalGenerator()->BuildCommandLine(ddCmds);
std::ostringstream ddComment;
ddComment << "Rule to generate ninja dyndep files for " << lang << ".";
std::ostringstream ddDesc;
ddDesc << "Generating " << lang << " dyndep file $out";
this->GetGlobalGenerator()->AddRule(
this->LanguageDyndepRule(lang), ddCmdLine, ddDesc.str(), ddComment.str(),
/*depfile*/ "",
/*deps*/ "",
/*rspfile*/ "",
/*rspcontent*/ "",
/*restat*/ "",
/*generator*/ false);
}
2011-11-11 09:00:49 +04:00
// Rule for compiling object file.
const std::string cmdVar = std::string("CMAKE_") + lang + "_COMPILE_OBJECT";
std::string compileCmd = mf->GetRequiredDefinition(cmdVar);
std::vector<std::string> compileCmds;
cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
2011-11-11 09:00:49 +04:00
// Maybe insert an include-what-you-use runner.
if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
const char* iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
std::string const tidy_prop = lang + "_CLANG_TIDY";
const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
if ((iwyu && *iwyu) || (tidy && *tidy)) {
std::string run_iwyu = this->GetLocalGenerator()->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
run_iwyu += " -E __run_iwyu";
if (iwyu && *iwyu) {
run_iwyu += " --iwyu=";
run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
}
if (tidy && *tidy) {
run_iwyu += " --tidy=";
run_iwyu += this->GetLocalGenerator()->EscapeForShell(tidy);
run_iwyu += " --source=$in";
}
run_iwyu += " -- ";
compileCmds.front().insert(0, run_iwyu);
}
}
// Maybe insert a compiler launcher like ccache or distcc
if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
const char* clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
if (clauncher && *clauncher) {
std::vector<std::string> launcher_cmd;
cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
e = launcher_cmd.end();
i != e; ++i) {
*i = this->LocalGenerator->EscapeForShell(*i);
}
std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
compileCmds.front().insert(0, run_launcher);
}
}
if (!compileCmds.empty()) {
compileCmds.front().insert(0, cldeps);
}
for (std::vector<std::string>::iterator i = compileCmds.begin();
i != compileCmds.end(); ++i) {
this->GetLocalGenerator()->ExpandRuleVariables(*i, vars);
}
std::string cmdLine =
this->GetLocalGenerator()->BuildCommandLine(compileCmds);
2011-11-11 09:00:49 +04:00
// Write the rule for compiling file of the given language.
std::ostringstream comment;
comment << "Rule for compiling " << lang << " files.";
std::ostringstream description;
description << "Building " << lang << " object $out";
this->GetGlobalGenerator()->AddRule(
this->LanguageCompilerRule(lang), cmdLine, description.str(),
comment.str(), depfile, deptype, rspfile, rspcontent,
/*restat*/ "",
/*generator*/ false);
2011-11-11 09:00:49 +04:00
}
void cmNinjaTargetGenerator::WriteObjectBuildStatements()
2011-11-11 09:00:49 +04:00
{
// Write comments.
cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
this->GetBuildFileStream()
<< "# Object build statements for "
<< cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
<< " target " << this->GetTargetName() << "\n\n";
2011-11-11 09:00:49 +04:00
std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
std::vector<cmSourceFile const*> customCommands;
this->GeneratorTarget->GetCustomCommands(customCommands, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
customCommands.begin();
si != customCommands.end(); ++si) {
cmCustomCommand const* cc = (*si)->GetCustomCommand();
this->GetLocalGenerator()->AddCustomCommandTarget(
cc, this->GetGeneratorTarget());
// Record the custom commands for this target. The container is used
// in WriteObjectBuildStatement when called in a loop below.
this->CustomCommands.push_back(cc);
}
std::vector<cmSourceFile const*> headerSources;
this->GeneratorTarget->GetHeaderSources(headerSources, config);
this->OSXBundleGenerator->GenerateMacOSXContentStatements(
headerSources, this->MacOSXContentGenerator);
std::vector<cmSourceFile const*> extraSources;
this->GeneratorTarget->GetExtraSources(extraSources, config);
this->OSXBundleGenerator->GenerateMacOSXContentStatements(
extraSources, this->MacOSXContentGenerator);
std::vector<cmSourceFile const*> externalObjects;
this->GeneratorTarget->GetExternalObjects(externalObjects, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
externalObjects.begin();
si != externalObjects.end(); ++si) {
this->Objects.push_back(this->GetSourceFilePath(*si));
}
cmNinjaDeps orderOnlyDeps;
2015-10-19 00:13:50 +03:00
this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget,
orderOnlyDeps);
// Add order-only dependencies on other files associated with the target.
orderOnlyDeps.insert(orderOnlyDeps.end(), this->ExtraFiles.begin(),
this->ExtraFiles.end());
// Add order-only dependencies on custom command outputs.
for (std::vector<cmCustomCommand const*>::const_iterator cci =
this->CustomCommands.begin();
cci != this->CustomCommands.end(); ++cci) {
cmCustomCommand const* cc = *cci;
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
this->GetLocalGenerator());
const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
const std::vector<std::string>& ccbyproducts = ccg.GetByproducts();
std::transform(ccoutputs.begin(), ccoutputs.end(),
std::back_inserter(orderOnlyDeps), MapToNinjaPath());
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
std::transform(ccbyproducts.begin(), ccbyproducts.end(),
std::back_inserter(orderOnlyDeps), MapToNinjaPath());
}
if (!orderOnlyDeps.empty()) {
cmNinjaDeps orderOnlyTarget;
orderOnlyTarget.push_back(this->OrderDependsTargetForTarget());
this->GetGlobalGenerator()->WritePhonyBuild(
this->GetBuildFileStream(),
"Order-only phony target for " + this->GetTargetName(), orderOnlyTarget,
cmNinjaDeps(), cmNinjaDeps(), orderOnlyDeps);
}
std::vector<cmSourceFile const*> objectSources;
this->GeneratorTarget->GetObjectSources(objectSources, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
objectSources.begin();
si != objectSources.end(); ++si) {
this->WriteObjectBuildStatement(*si, !orderOnlyDeps.empty());
}
2011-11-11 09:00:49 +04:00
if (!this->DDIFiles.empty()) {
std::string const ddComment;
std::string const ddRule = this->LanguageDyndepRule("Fortran");
cmNinjaDeps ddOutputs;
cmNinjaDeps ddImplicitOuts;
cmNinjaDeps const& ddExplicitDeps = this->DDIFiles;
cmNinjaDeps ddImplicitDeps;
cmNinjaDeps ddOrderOnlyDeps;
cmNinjaVars ddVars;
this->WriteTargetDependInfo("Fortran");
ddOutputs.push_back(this->GetDyndepFilePath("Fortran"));
this->GetGlobalGenerator()->WriteBuild(
this->GetBuildFileStream(), ddComment, ddRule, ddOutputs, ddImplicitOuts,
ddExplicitDeps, ddImplicitDeps, ddOrderOnlyDeps, ddVars);
}
2011-11-11 09:00:49 +04:00
this->GetBuildFileStream() << "\n";
}
void cmNinjaTargetGenerator::WriteObjectBuildStatement(
cmSourceFile const* source, bool writeOrderDependsTargetForTarget)
2011-11-11 09:00:49 +04:00
{
std::string const language = source->GetLanguage();
std::string const sourceFileName = this->GetSourceFilePath(source);
std::string const objectDir =
this->ConvertToNinjaPath(this->GeneratorTarget->GetSupportDirectory());
std::string const objectFileName =
this->ConvertToNinjaPath(this->GetObjectFilePath(source));
std::string const objectFileDir =
cmSystemTools::GetFilenamePath(objectFileName);
cmNinjaVars vars;
vars["IN_ABS"] = this->GetLocalGenerator()->ConvertToOutputFormat(
source->GetFullPath(), cmOutputConverter::SHELL);
vars["FLAGS"] = this->ComputeFlagsForObject(source, language);
vars["DEFINES"] = this->ComputeDefines(source, language);
vars["INCLUDES"] = this->GetIncludes(language);
if (!this->NeedDepTypeMSVC(language)) {
vars["DEP_FILE"] =
cmGlobalNinjaGenerator::EncodeDepfileSpace(objectFileName + ".d");
}
this->ExportObjectCompileCommand(
language, sourceFileName, objectDir, objectFileName, objectFileDir,
vars["FLAGS"], vars["DEFINES"], vars["INCLUDES"]);
2011-11-11 09:00:49 +04:00
std::string comment;
std::string rule = this->LanguageCompilerRule(language);
cmNinjaDeps outputs;
outputs.push_back(objectFileName);
// Add this object to the list of object files.
this->Objects.push_back(objectFileName);
cmNinjaDeps explicitDeps;
explicitDeps.push_back(sourceFileName);
cmNinjaDeps implicitDeps;
if (const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
2011-11-11 09:00:49 +04:00
std::vector<std::string> depList;
cmSystemTools::ExpandListArgument(objectDeps, depList);
for (std::vector<std::string>::iterator odi = depList.begin();
odi != depList.end(); ++odi) {
if (cmSystemTools::FileIsFullPath(*odi)) {
*odi = cmSystemTools::CollapseFullPath(*odi);
}
}
2011-11-11 09:00:49 +04:00
std::transform(depList.begin(), depList.end(),
std::back_inserter(implicitDeps), MapToNinjaPath());
2011-11-11 09:00:49 +04:00
}
cmNinjaDeps orderOnlyDeps;
if (writeOrderDependsTargetForTarget) {
orderOnlyDeps.push_back(this->OrderDependsTargetForTarget());
}
2011-11-11 09:00:49 +04:00
// If the source file is GENERATED and does not have a custom command
// (either attached to this source file or another one), assume that one of
// the target dependencies, OBJECT_DEPENDS or header file custom commands
// will rebuild the file.
if (source->GetPropertyAsBool("GENERATED") && !source->GetCustomCommand() &&
!this->GetGlobalGenerator()->HasCustomCommandOutput(sourceFileName)) {
this->GetGlobalGenerator()->AddAssumedSourceDependencies(sourceFileName,
orderOnlyDeps);
}
// For some cases we need to generate a ninja dyndep file.
bool const needDyndep = this->NeedDyndep(language);
// For some cases we do an explicit preprocessor invocation.
bool const explicitPP = this->NeedExplicitPreprocessing(language);
if (explicitPP) {
std::string const ppComment;
std::string const ppRule = this->LanguagePreprocessRule(language);
cmNinjaDeps ppOutputs;
cmNinjaDeps ppImplicitOuts;
cmNinjaDeps ppExplicitDeps;
cmNinjaDeps ppImplicitDeps;
cmNinjaDeps ppOrderOnlyDeps;
cmNinjaVars ppVars;
std::string const ppFileName =
this->ConvertToNinjaPath(this->GetPreprocessedFilePath(source));
ppOutputs.push_back(ppFileName);
// Move compilation dependencies to the preprocessing build statement.
std::swap(ppExplicitDeps, explicitDeps);
std::swap(ppImplicitDeps, implicitDeps);
std::swap(ppOrderOnlyDeps, orderOnlyDeps);
std::swap(ppVars["IN_ABS"], vars["IN_ABS"]);
// The actual compilation will now use the preprocessed source.
explicitDeps.push_back(ppFileName);
// Preprocessing and compilation use the same flags.
ppVars["FLAGS"] = vars["FLAGS"];
// Move preprocessor definitions to the preprocessor build statement.
std::swap(ppVars["DEFINES"], vars["DEFINES"]);
// Copy include directories to the preprocessor build statement. The
// Fortran compilation build statement still needs them for the INCLUDE
// directive.
ppVars["INCLUDES"] = vars["INCLUDES"];
// Prepend source file's original directory as an include directory
// so e.g. Fortran INCLUDE statements can look for files in it.
std::vector<std::string> sourceDirectory;
sourceDirectory.push_back(
cmSystemTools::GetParentDirectory(source->GetFullPath()));
std::string sourceDirectoryFlag = this->LocalGenerator->GetIncludeFlags(
sourceDirectory, this->GeneratorTarget, language, false, false,
this->GetConfigName());
vars["INCLUDES"] = sourceDirectoryFlag + " " + vars["INCLUDES"];
// Explicit preprocessing always uses a depfile.
ppVars["DEP_FILE"] =
cmGlobalNinjaGenerator::EncodeDepfileSpace(ppFileName + ".d");
// The actual compilation does not need a depfile because it
// depends on the already-preprocessed source.
vars.erase("DEP_FILE");
if (needDyndep) {
// Tell dependency scanner the object file that will result from
// compiling the preprocessed source.
ppVars["OBJ_FILE"] = objectFileName;
// Tell dependency scanner where to store dyndep intermediate results.
std::string const ddiFile = ppFileName + ".ddi";
ppVars["DYNDEP_INTERMEDIATE_FILE"] = ddiFile;
ppImplicitOuts.push_back(ddiFile);
this->DDIFiles.push_back(ddiFile);
}
this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
ppVars);
this->GetGlobalGenerator()->WriteBuild(
this->GetBuildFileStream(), ppComment, ppRule, ppOutputs, ppImplicitOuts,
ppExplicitDeps, ppImplicitDeps, ppOrderOnlyDeps, ppVars);
}
if (needDyndep) {
std::string const dyndep = this->GetDyndepFilePath(language);
orderOnlyDeps.push_back(dyndep);
vars["dyndep"] = dyndep;
}
EnsureParentDirectoryExists(objectFileName);
2012-06-12 06:17:55 +04:00
vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
objectDir, cmOutputConverter::SHELL);
vars["OBJECT_FILE_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
objectFileDir, cmOutputConverter::SHELL);
this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
vars);
this->SetMsvcTargetPdbVariable(vars);
2011-11-11 09:00:49 +04:00
bool const isRC = (language == "RC");
int const commandLineLengthLimit =
((!isRC && this->ForceResponseFile())) ? -1 : 0;
std::string const rspfile = objectFileName + ".rsp";
this->GetGlobalGenerator()->WriteBuild(
this->GetBuildFileStream(), comment, rule, outputs,
/*implicitOuts=*/cmNinjaDeps(), explicitDeps, implicitDeps, orderOnlyDeps,
vars, rspfile, commandLineLengthLimit);
if (const char* objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
std::vector<std::string> outputList;
cmSystemTools::ExpandListArgument(objectOutputs, outputList);
std::transform(outputList.begin(), outputList.end(), outputList.begin(),
MapToNinjaPath());
this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
"Additional output files.",
outputList, outputs);
}
2011-11-11 09:00:49 +04:00
}
2012-03-07 02:41:40 +04:00
void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang)
{
Json::Value tdi(Json::objectValue);
tdi["language"] = lang;
tdi["compiler-id"] =
this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID");
if (lang == "Fortran") {
std::string mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(
this->Makefile->GetHomeOutputDirectory());
if (mod_dir.empty()) {
mod_dir = this->Makefile->GetCurrentBinaryDirectory();
}
tdi["module-dir"] = mod_dir;
}
tdi["dir-cur-bld"] = this->Makefile->GetCurrentBinaryDirectory();
tdi["dir-cur-src"] = this->Makefile->GetCurrentSourceDirectory();
tdi["dir-top-bld"] = this->Makefile->GetHomeOutputDirectory();
tdi["dir-top-src"] = this->Makefile->GetHomeDirectory();
Json::Value& tdi_include_dirs = tdi["include-dirs"] = Json::arrayValue;
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
lang, this->GetConfigName());
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
tdi_include_dirs.append(*i);
}
Json::Value& tdi_linked_target_dirs = tdi["linked-target-dirs"] =
Json::arrayValue;
std::vector<std::string> linked = this->GetLinkedTargetDirectories();
for (std::vector<std::string>::iterator i = linked.begin();
i != linked.end(); ++i) {
tdi_linked_target_dirs.append(*i);
}
std::string const tdin = this->GetTargetDependInfoPath(lang);
cmGeneratedFileStream tdif(tdin.c_str());
tdif << tdi;
}
void cmNinjaTargetGenerator::ExportObjectCompileCommand(
std::string const& language, std::string const& sourceFileName,
std::string const& objectDir, std::string const& objectFileName,
std::string const& objectFileDir, std::string const& flags,
std::string const& defines, std::string const& includes)
{
if (!this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS")) {
return;
}
cmLocalGenerator::RuleVariables compileObjectVars;
compileObjectVars.Language = language.c_str();
std::string escapedSourceFileName = sourceFileName;
if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str())) {
escapedSourceFileName = cmSystemTools::CollapseFullPath(
escapedSourceFileName, this->GetGlobalGenerator()
->GetCMakeInstance()
->GetHomeOutputDirectory());
}
escapedSourceFileName = this->LocalGenerator->ConvertToOutputFormat(
escapedSourceFileName, cmOutputConverter::SHELL);
compileObjectVars.Source = escapedSourceFileName.c_str();
compileObjectVars.Object = objectFileName.c_str();
compileObjectVars.ObjectDir = objectDir.c_str();
compileObjectVars.ObjectFileDir = objectFileDir.c_str();
compileObjectVars.Flags = flags.c_str();
compileObjectVars.Defines = defines.c_str();
compileObjectVars.Includes = includes.c_str();
// Rule for compiling object file.
std::string compileCmdVar = "CMAKE_";
compileCmdVar += language;
compileCmdVar += "_COMPILE_OBJECT";
std::string compileCmd =
this->GetMakefile()->GetRequiredDefinition(compileCmdVar);
std::vector<std::string> compileCmds;
cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
for (std::vector<std::string>::iterator i = compileCmds.begin();
i != compileCmds.end(); ++i) {
this->GetLocalGenerator()->ExpandRuleVariables(*i, compileObjectVars);
}
std::string cmdLine =
this->GetLocalGenerator()->BuildCommandLine(compileCmds);
this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine, sourceFileName);
}
void cmNinjaTargetGenerator::EnsureDirectoryExists(
const std::string& path) const
{
if (cmSystemTools::FileIsFullPath(path.c_str())) {
cmSystemTools::MakeDirectory(path.c_str());
} else {
cmGlobalNinjaGenerator* gg = this->GetGlobalGenerator();
std::string fullPath =
std::string(gg->GetCMakeInstance()->GetHomeOutputDirectory());
// Also ensures their is a trailing slash.
gg->StripNinjaOutputPathPrefixAsSuffix(fullPath);
fullPath += path;
cmSystemTools::MakeDirectory(fullPath.c_str());
}
}
void cmNinjaTargetGenerator::EnsureParentDirectoryExists(
const std::string& path) const
{
EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
}
void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
cmSourceFile const& source, const char* pkgloc)
{
// Skip OS X content when not building a Framework or Bundle.
if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
return;
}
std::string macdir =
this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc);
// Get the input file location.
std::string input = source.GetFullPath();
input = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input);
// Get the output file location.
std::string output = macdir;
output += "/";
output += cmSystemTools::GetFilenameName(input);
output = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output);
// Write a build statement to copy the content into the bundle.
this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(input,
output);
// Add as a dependency to the target so that it gets called.
this->Generator->ExtraFiles.push_back(output);
}
2014-03-11 02:32:00 +04:00
void cmNinjaTargetGenerator::addPoolNinjaVariable(
const std::string& pool_property, cmGeneratorTarget* target,
cmNinjaVars& vars)
{
const char* pool = target->GetProperty(pool_property);
if (pool) {
vars["pool"] = pool;
}
}
bool cmNinjaTargetGenerator::ForceResponseFile()
{
static std::string const forceRspFile = "CMAKE_NINJA_FORCE_RESPONSE_FILE";
return (this->GetMakefile()->IsDefinitionSet(forceRspFile) ||
cmSystemTools::HasEnv(forceRspFile));
}