1 /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2 file Copyright.txt or https://cmake.org/licensing for details. */
3 #include "cmNinjaTargetGenerator.h"
10 #include <unordered_map>
11 #include <unordered_set>
15 #include <cm/string_view>
16 #include <cmext/algorithm>
17 #include <cmext/string_view>
19 #include <cm3p/json/value.h>
20 #include <cm3p/json/writer.h>
22 #include "cmComputeLinkInformation.h"
23 #include "cmCustomCommandGenerator.h"
24 #include "cmExportBuildFileGenerator.h"
25 #include "cmExportSet.h"
26 #include "cmFileSet.h"
27 #include "cmGeneratedFileStream.h"
28 #include "cmGeneratorExpression.h"
29 #include "cmGeneratorTarget.h"
30 #include "cmGlobalNinjaGenerator.h"
31 #include "cmInstallCxxModuleBmiGenerator.h"
32 #include "cmInstallExportGenerator.h"
33 #include "cmInstallFileSetGenerator.h"
34 #include "cmInstallGenerator.h"
35 #include "cmLocalGenerator.h"
36 #include "cmLocalNinjaGenerator.h"
37 #include "cmMakefile.h"
38 #include "cmMessageType.h"
39 #include "cmNinjaNormalTargetGenerator.h"
40 #include "cmNinjaUtilityTargetGenerator.h"
41 #include "cmOutputConverter.h"
43 #include "cmRulePlaceholderExpander.h"
44 #include "cmSourceFile.h"
46 #include "cmStateTypes.h"
47 #include "cmStringAlgorithms.h"
48 #include "cmSystemTools.h"
50 #include "cmTargetExport.h"
54 std::unique_ptr<cmNinjaTargetGenerator> cmNinjaTargetGenerator::New(
55 cmGeneratorTarget* target)
57 switch (target->GetType()) {
58 case cmStateEnums::EXECUTABLE:
59 case cmStateEnums::SHARED_LIBRARY:
60 case cmStateEnums::STATIC_LIBRARY:
61 case cmStateEnums::MODULE_LIBRARY:
62 case cmStateEnums::OBJECT_LIBRARY:
63 return cm::make_unique<cmNinjaNormalTargetGenerator>(target);
65 case cmStateEnums::UTILITY:
66 case cmStateEnums::INTERFACE_LIBRARY:
67 case cmStateEnums::GLOBAL_TARGET:
68 return cm::make_unique<cmNinjaUtilityTargetGenerator>(target);
71 return std::unique_ptr<cmNinjaTargetGenerator>();
75 cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
76 : cmCommonTargetGenerator(target)
77 , OSXBundleGenerator(nullptr)
79 static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator()))
81 for (auto const& fileConfig :
82 target->Makefile->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig)) {
83 this->Configs[fileConfig].MacOSXContentGenerator =
84 cm::make_unique<MacOSXContentGeneratorType>(this, fileConfig);
88 cmNinjaTargetGenerator::~cmNinjaTargetGenerator() = default;
90 cmGeneratedFileStream& cmNinjaTargetGenerator::GetImplFileStream(
91 const std::string& config) const
93 return *this->GetGlobalGenerator()->GetImplFileStream(config);
96 cmGeneratedFileStream& cmNinjaTargetGenerator::GetCommonFileStream() const
98 return *this->GetGlobalGenerator()->GetCommonFileStream();
101 cmGeneratedFileStream& cmNinjaTargetGenerator::GetRulesFileStream() const
103 return *this->GetGlobalGenerator()->GetRulesFileStream();
106 cmGlobalNinjaGenerator* cmNinjaTargetGenerator::GetGlobalGenerator() const
108 return this->LocalGenerator->GetGlobalNinjaGenerator();
111 std::string cmNinjaTargetGenerator::LanguageCompilerRule(
112 const std::string& lang, const std::string& config) const
116 cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
120 std::string cmNinjaTargetGenerator::LanguagePreprocessAndScanRule(
121 std::string const& lang, const std::string& config) const
124 lang, "_PREPROCESS_SCAN__",
125 cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
129 std::string cmNinjaTargetGenerator::LanguageScanRule(
130 std::string const& lang, const std::string& config) const
134 cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
138 bool cmNinjaTargetGenerator::NeedExplicitPreprocessing(
139 std::string const& lang) const
141 return lang == "Fortran";
144 bool cmNinjaTargetGenerator::CompileWithDefines(std::string const& lang) const
146 return this->Makefile->IsOn(
147 cmStrCat("CMAKE_", lang, "_COMPILE_WITH_DEFINES"));
150 std::string cmNinjaTargetGenerator::LanguageDyndepRule(
151 const std::string& lang, const std::string& config) const
155 cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
159 bool cmNinjaTargetGenerator::NeedCxxModuleSupport(
160 std::string const& lang, std::string const& config) const
162 if (lang != "CXX"_s) {
165 return this->GetGeneratorTarget()->HaveCxxModuleSupport(config) ==
166 cmGeneratorTarget::Cxx20SupportLevel::Supported &&
167 this->GetGlobalGenerator()->CheckCxxModuleSupport();
170 bool cmNinjaTargetGenerator::NeedDyndep(std::string const& lang,
171 std::string const& config) const
173 return lang == "Fortran" || this->NeedCxxModuleSupport(lang, config);
176 std::string cmNinjaTargetGenerator::OrderDependsTargetForTarget(
177 const std::string& config)
179 return this->GetGlobalGenerator()->OrderDependsTargetForTarget(
180 this->GeneratorTarget, config);
183 // TODO: Most of the code is picked up from
184 // void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink),
185 // void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
187 std::string cmNinjaTargetGenerator::ComputeFlagsForObject(
188 cmSourceFile const* source, const std::string& language,
189 const std::string& config)
191 std::vector<std::string> architectures;
192 std::unordered_map<std::string, std::string> pchSources;
193 this->GeneratorTarget->GetAppleArchs(config, architectures);
194 if (architectures.empty()) {
195 architectures.emplace_back();
198 std::string filterArch;
199 for (const std::string& arch : architectures) {
200 const std::string pchSource =
201 this->GeneratorTarget->GetPchSource(config, language, arch);
202 if (pchSource == source->GetFullPath()) {
205 if (!pchSource.empty()) {
206 pchSources.insert(std::make_pair(pchSource, arch));
211 // Explicitly add the explicit language flag before any other flag
212 // so user flags can override it.
213 this->GeneratorTarget->AddExplicitLanguageFlags(flags, *source);
215 if (!flags.empty()) {
218 flags += this->GetFlags(language, config, filterArch);
220 // Add Fortran format flags.
221 if (language == "Fortran") {
222 this->AppendFortranFormatFlags(flags, *source);
223 this->AppendFortranPreprocessFlags(flags, *source,
224 PreprocessFlagsRequired::NO);
227 // Add source file specific flags.
228 cmGeneratorExpressionInterpreter genexInterpreter(
229 this->LocalGenerator, config, this->GeneratorTarget, language);
231 const std::string COMPILE_FLAGS("COMPILE_FLAGS");
232 if (cmValue cflags = source->GetProperty(COMPILE_FLAGS)) {
233 this->LocalGenerator->AppendFlags(
234 flags, genexInterpreter.Evaluate(*cflags, COMPILE_FLAGS));
237 const std::string COMPILE_OPTIONS("COMPILE_OPTIONS");
238 if (cmValue coptions = source->GetProperty(COMPILE_OPTIONS)) {
239 this->LocalGenerator->AppendCompileOptions(
240 flags, genexInterpreter.Evaluate(*coptions, COMPILE_OPTIONS));
243 // Add precompile headers compile options.
244 if (!pchSources.empty() && !source->GetProperty("SKIP_PRECOMPILE_HEADERS")) {
245 std::string pchOptions;
246 auto pchIt = pchSources.find(source->GetFullPath());
247 if (pchIt != pchSources.end()) {
248 pchOptions = this->GeneratorTarget->GetPchCreateCompileOptions(
249 config, language, pchIt->second);
252 this->GeneratorTarget->GetPchUseCompileOptions(config, language);
255 this->LocalGenerator->AppendCompileOptions(
256 flags, genexInterpreter.Evaluate(pchOptions, COMPILE_OPTIONS));
259 auto const& path = source->GetFullPath();
260 auto const* tgt = this->GeneratorTarget->Target;
262 std::string file_set_type;
264 for (auto const& name : tgt->GetAllFileSetNames()) {
265 auto const* file_set = tgt->GetFileSet(name);
267 this->GetMakefile()->IssueMessage(
268 MessageType::INTERNAL_ERROR,
269 cmStrCat("Target \"", tgt->GetName(),
270 "\" is tracked to have file set \"", name,
271 "\", but it was not found."));
275 auto fileEntries = file_set->CompileFileEntries();
276 auto directoryEntries = file_set->CompileDirectoryEntries();
277 auto directories = file_set->EvaluateDirectoryEntries(
278 directoryEntries, this->LocalGenerator, config, this->GeneratorTarget);
280 std::map<std::string, std::vector<std::string>> files;
281 for (auto const& entry : fileEntries) {
282 file_set->EvaluateFileEntry(directories, files, entry,
283 this->LocalGenerator, config,
284 this->GeneratorTarget);
287 for (auto const& it : files) {
288 for (auto const& filename : it.second) {
289 if (filename == path) {
290 file_set_type = file_set->GetType();
296 if (file_set_type == "CXX_MODULES"_s ||
297 file_set_type == "CXX_MODULE_HEADER_UNITS"_s) {
298 if (source->GetLanguage() != "CXX"_s) {
299 this->GetMakefile()->IssueMessage(
300 MessageType::FATAL_ERROR,
302 "Target \"", tgt->GetName(), "\" contains the source\n ", path,
303 "\nin a file set of type \"", file_set_type,
304 R"(" but the source is not classified as a "CXX" source.)"));
313 void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
314 std::string const& language,
315 const std::string& config)
317 std::vector<std::string> includes;
318 this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
320 // Add include directory flags.
321 std::string includeFlags = this->LocalGenerator->GetIncludeFlags(
322 includes, this->GeneratorTarget, language, config, false);
323 if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
324 std::replace(includeFlags.begin(), includeFlags.end(), '\\', '/');
327 this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
330 // TODO: Refactor with
331 // void cmMakefileTargetGenerator::WriteTargetLanguageFlags().
332 std::string cmNinjaTargetGenerator::ComputeDefines(cmSourceFile const* source,
333 const std::string& language,
334 const std::string& config)
336 std::set<std::string> defines;
337 cmGeneratorExpressionInterpreter genexInterpreter(
338 this->LocalGenerator, config, this->GeneratorTarget, language);
341 if (this->GetGlobalGenerator()->IsMultiConfig()) {
342 defines.insert(cmStrCat("CMAKE_INTDIR=\"", config, '"'));
345 const std::string COMPILE_DEFINITIONS("COMPILE_DEFINITIONS");
346 if (cmValue compile_defs = source->GetProperty(COMPILE_DEFINITIONS)) {
347 this->LocalGenerator->AppendDefines(
348 defines, genexInterpreter.Evaluate(*compile_defs, COMPILE_DEFINITIONS));
351 std::string defPropName =
352 cmStrCat("COMPILE_DEFINITIONS_", cmSystemTools::UpperCase(config));
353 if (cmValue config_compile_defs = source->GetProperty(defPropName)) {
354 this->LocalGenerator->AppendDefines(
356 genexInterpreter.Evaluate(*config_compile_defs, COMPILE_DEFINITIONS));
359 std::string definesString = this->GetDefines(language, config);
360 this->LocalGenerator->JoinDefines(defines, definesString, language);
362 return definesString;
365 std::string cmNinjaTargetGenerator::ComputeIncludes(
366 cmSourceFile const* source, const std::string& language,
367 const std::string& config)
369 std::vector<std::string> includes;
370 cmGeneratorExpressionInterpreter genexInterpreter(
371 this->LocalGenerator, config, this->GeneratorTarget, language);
373 const std::string INCLUDE_DIRECTORIES("INCLUDE_DIRECTORIES");
374 if (cmValue cincludes = source->GetProperty(INCLUDE_DIRECTORIES)) {
375 this->LocalGenerator->AppendIncludeDirectories(
376 includes, genexInterpreter.Evaluate(*cincludes, INCLUDE_DIRECTORIES),
380 std::string includesString = this->LocalGenerator->GetIncludeFlags(
381 includes, this->GeneratorTarget, language, config, false);
382 this->LocalGenerator->AppendFlags(includesString,
383 this->GetIncludes(language, config));
385 return includesString;
388 cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps(
389 const std::string& linkLanguage, const std::string& config,
390 bool ignoreType) const
392 // Static libraries never depend on other targets for linking.
394 (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
395 this->GeneratorTarget->GetType() == cmStateEnums::OBJECT_LIBRARY)) {
396 return cmNinjaDeps();
399 cmComputeLinkInformation* cli =
400 this->GeneratorTarget->GetLinkInformation(config);
402 return cmNinjaDeps();
405 const std::vector<std::string>& deps = cli->GetDepends();
406 cmNinjaDeps result(deps.size());
407 std::transform(deps.begin(), deps.end(), result.begin(),
408 this->MapToNinjaPath());
410 // Add a dependency on the link definitions file, if any.
411 if (cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
412 this->GeneratorTarget->GetModuleDefinitionInfo(config)) {
413 for (cmSourceFile const* src : mdi->Sources) {
414 result.push_back(this->ConvertToNinjaPath(src->GetFullPath()));
418 // Add a dependency on user-specified manifest files, if any.
419 std::vector<cmSourceFile const*> manifest_srcs;
420 this->GeneratorTarget->GetManifests(manifest_srcs, config);
421 for (cmSourceFile const* manifest_src : manifest_srcs) {
422 result.push_back(this->ConvertToNinjaPath(manifest_src->GetFullPath()));
425 // Add user-specified dependencies.
426 std::vector<std::string> linkDeps;
427 this->GeneratorTarget->GetLinkDepends(linkDeps, config, linkLanguage);
428 std::transform(linkDeps.begin(), linkDeps.end(), std::back_inserter(result),
429 this->MapToNinjaPath());
434 std::string cmNinjaTargetGenerator::GetCompiledSourceNinjaPath(
435 cmSourceFile const* source) const
437 // Pass source files to the compiler by absolute path.
438 return this->ConvertToNinjaAbsPath(source->GetFullPath());
441 std::string cmNinjaTargetGenerator::GetObjectFilePath(
442 cmSourceFile const* source, const std::string& config) const
444 std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
448 std::string const& objectName = this->GeneratorTarget->GetObjectName(source);
450 this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
451 this->GetGlobalGenerator()->ConfigDirectory(config), '/', objectName);
455 std::string cmNinjaTargetGenerator::GetPreprocessedFilePath(
456 cmSourceFile const* source, const std::string& config) const
458 // Choose an extension to compile already-preprocessed source.
459 std::string ppExt = source->GetExtension();
460 if (cmHasLiteralPrefix(ppExt, "F")) {
461 // Some Fortran compilers automatically enable preprocessing for
462 // upper-case extensions. Since the source is already preprocessed,
463 // use a lower-case extension.
464 ppExt = cmSystemTools::LowerCase(ppExt);
466 if (ppExt == "fpp") {
467 // Some Fortran compilers automatically enable preprocessing for
468 // the ".fpp" extension. Since the source is already preprocessed,
469 // use the ".f" extension.
473 // Take the object file name and replace the extension.
474 std::string const& objName = this->GeneratorTarget->GetObjectName(source);
475 std::string const& objExt =
476 this->GetGlobalGenerator()->GetLanguageOutputExtension(*source);
477 assert(objName.size() >= objExt.size());
478 std::string const ppName =
479 cmStrCat(objName.substr(0, objName.size() - objExt.size()), "-pp.", ppExt);
481 std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
486 cmStrCat(this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
487 this->GetGlobalGenerator()->ConfigDirectory(config), '/', ppName);
491 std::string cmNinjaTargetGenerator::GetDyndepFilePath(
492 std::string const& lang, const std::string& config) const
494 std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
499 this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
500 this->GetGlobalGenerator()->ConfigDirectory(config), '/', lang, ".dd");
504 std::string cmNinjaTargetGenerator::GetTargetDependInfoPath(
505 std::string const& lang, const std::string& config) const
508 cmStrCat(this->Makefile->GetCurrentBinaryDirectory(), '/',
509 this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
510 this->GetGlobalGenerator()->ConfigDirectory(config), '/', lang,
515 std::string cmNinjaTargetGenerator::GetTargetOutputDir(
516 const std::string& config) const
518 std::string dir = this->GeneratorTarget->GetDirectory(config);
519 return this->ConvertToNinjaPath(dir);
522 std::string cmNinjaTargetGenerator::GetTargetFilePath(
523 const std::string& name, const std::string& config) const
525 std::string path = this->GetTargetOutputDir(config);
526 if (path.empty() || path == ".") {
529 path += cmStrCat('/', name);
533 std::string cmNinjaTargetGenerator::GetTargetName() const
535 return this->GeneratorTarget->GetName();
538 bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(
539 cmNinjaVars& vars, const std::string& config) const
541 cmMakefile* mf = this->GetMakefile();
542 if (mf->GetDefinition("MSVC_C_ARCHITECTURE_ID") ||
543 mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID") ||
544 mf->GetDefinition("MSVC_CUDA_ARCHITECTURE_ID")) {
546 std::string compilePdbPath = this->ComputeTargetCompilePDB(config);
547 if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||
548 this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
549 this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
550 this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
551 pdbPath = cmStrCat(this->GeneratorTarget->GetPDBDirectory(config), '/',
552 this->GeneratorTarget->GetPDBName(config));
555 vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
556 this->ConvertToNinjaPath(pdbPath), cmOutputConverter::SHELL);
557 vars["TARGET_COMPILE_PDB"] =
558 this->GetLocalGenerator()->ConvertToOutputFormat(
559 this->ConvertToNinjaPath(compilePdbPath), cmOutputConverter::SHELL);
561 this->EnsureParentDirectoryExists(pdbPath);
562 this->EnsureParentDirectoryExists(compilePdbPath);
568 void cmNinjaTargetGenerator::WriteLanguageRules(const std::string& language,
569 const std::string& config)
571 #ifdef NINJA_GEN_VERBOSE_FILES
572 this->GetRulesFileStream() << "# Rules for language " << language << "\n\n";
574 this->WriteCompileRule(language, config);
578 // Create the command to run the dependency scanner
579 std::string GetScanCommand(const std::string& cmakeCmd, const std::string& tdi,
580 const std::string& lang, const std::string& ppFile,
581 const std::string& ddiFile)
583 return cmStrCat(cmakeCmd, " -E cmake_ninja_depends --tdi=", tdi,
584 " --lang=", lang, " --pp=", ppFile,
585 " --dep=$DEP_FILE --obj=$OBJ_FILE --ddi=", ddiFile);
588 // Helper function to create dependency scanning rule that may or may
589 // not perform explicit preprocessing too.
590 cmNinjaRule GetScanRule(
591 std::string const& ruleName, std::string const& ppFileName,
592 std::string const& deptype,
593 cmRulePlaceholderExpander::RuleVariables const& vars,
594 const std::string& responseFlag, const std::string& flags,
595 cmRulePlaceholderExpander* const rulePlaceholderExpander,
596 cmLocalNinjaGenerator* generator, std::vector<std::string> scanCmds,
597 const std::string& outputConfig)
599 cmNinjaRule rule(ruleName);
600 // Scanning always uses a depfile for preprocessor dependencies.
601 if (deptype == "msvc"_s) {
602 rule.DepType = deptype;
605 rule.DepType = ""; // no deps= for multiple outputs
606 rule.DepFile = "$DEP_FILE";
609 cmRulePlaceholderExpander::RuleVariables scanVars;
610 scanVars.CMTargetName = vars.CMTargetName;
611 scanVars.CMTargetType = vars.CMTargetType;
612 scanVars.Language = vars.Language;
613 scanVars.Object = "$OBJ_FILE";
614 scanVars.PreprocessedSource = ppFileName.c_str();
615 scanVars.DynDepFile = "$DYNDEP_INTERMEDIATE_FILE";
616 scanVars.DependencyFile = rule.DepFile.c_str();
617 scanVars.DependencyTarget = "$out";
619 // Scanning needs the same preprocessor settings as direct compilation would.
620 scanVars.Source = vars.Source;
621 scanVars.Defines = vars.Defines;
622 scanVars.Includes = vars.Includes;
624 // Scanning needs the compilation flags too.
625 std::string scanFlags = flags;
627 // If using a response file, move defines, includes, and flags into it.
628 if (!responseFlag.empty()) {
629 rule.RspFile = "$RSP_FILE";
631 cmStrCat(' ', scanVars.Defines, ' ', scanVars.Includes, ' ', scanFlags);
632 scanFlags = cmStrCat(responseFlag, rule.RspFile);
633 scanVars.Defines = "";
634 scanVars.Includes = "";
637 scanVars.Flags = scanFlags.c_str();
639 // Rule for scanning a source file.
640 for (std::string& scanCmd : scanCmds) {
641 rulePlaceholderExpander->ExpandRuleVariables(generator, scanCmd, scanVars);
644 generator->BuildCommandLine(scanCmds, outputConfig, outputConfig);
650 void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
651 const std::string& config)
653 cmRulePlaceholderExpander::RuleVariables vars;
654 vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str();
656 cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()).c_str();
657 vars.Language = lang.c_str();
659 vars.Object = "$out";
660 vars.Defines = "$DEFINES";
661 vars.Includes = "$INCLUDES";
662 vars.TargetPDB = "$TARGET_PDB";
663 vars.TargetCompilePDB = "$TARGET_COMPILE_PDB";
664 vars.ObjectDir = "$OBJECT_DIR";
665 vars.ObjectFileDir = "$OBJECT_FILE_DIR";
666 vars.CudaCompileMode = "$CUDA_COMPILE_MODE";
667 vars.ISPCHeader = "$ISPC_HEADER_FILE";
669 cmMakefile* mf = this->GetMakefile();
671 // For some cases we scan to dynamically discover dependencies.
672 bool const needDyndep = this->NeedDyndep(lang, config);
673 bool const compilationPreprocesses = !this->NeedExplicitPreprocessing(lang);
675 std::string flags = "$FLAGS";
677 std::string responseFlag;
678 bool const lang_supports_response = lang != "RC";
679 if (lang_supports_response && this->ForceResponseFile()) {
680 std::string const responseFlagVar =
681 cmStrCat("CMAKE_", lang, "_RESPONSE_FILE_FLAG");
682 responseFlag = this->Makefile->GetSafeDefinition(responseFlagVar);
683 if (responseFlag.empty() && lang != "CUDA") {
687 std::string const modmapFormatVar =
688 cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FORMAT");
689 std::string const modmapFormat =
690 this->Makefile->GetSafeDefinition(modmapFormatVar);
692 std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
693 this->GetLocalGenerator()->CreateRulePlaceholderExpander());
695 std::string const tdi = this->GetLocalGenerator()->ConvertToOutputFormat(
696 this->ConvertToNinjaPath(this->GetTargetDependInfoPath(lang, config)),
697 cmLocalGenerator::SHELL);
699 std::string launcher;
700 cmValue val = this->GetLocalGenerator()->GetRuleLauncher(
701 this->GetGeneratorTarget(), "RULE_LAUNCH_COMPILE");
702 if (cmNonempty(val)) {
703 launcher = cmStrCat(*val, ' ');
706 std::string const cmakeCmd =
707 this->GetLocalGenerator()->ConvertToOutputFormat(
708 cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
711 const auto& scanDepType = this->GetMakefile()->GetSafeDefinition(
712 cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_SCANDEP_DEPFILE_FORMAT"));
714 // Rule to scan dependencies of sources that need preprocessing.
716 std::vector<std::string> scanCommands;
717 std::string scanRuleName;
718 std::string ppFileName;
719 if (compilationPreprocesses) {
720 scanRuleName = this->LanguageScanRule(lang, config);
721 ppFileName = "$PREPROCESSED_OUTPUT_FILE";
722 std::string const& scanCommand = mf->GetRequiredDefinition(
723 cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_SCANDEP_SOURCE"));
724 cmExpandList(scanCommand, scanCommands);
725 for (std::string& i : scanCommands) {
726 i = cmStrCat(launcher, i);
729 scanRuleName = this->LanguagePreprocessAndScanRule(lang, config);
731 std::string const& ppCommmand = mf->GetRequiredDefinition(
732 cmStrCat("CMAKE_", lang, "_PREPROCESS_SOURCE"));
733 cmExpandList(ppCommmand, scanCommands);
734 for (std::string& i : scanCommands) {
735 i = cmStrCat(launcher, i);
737 scanCommands.emplace_back(GetScanCommand(cmakeCmd, tdi, lang, "$out",
738 "$DYNDEP_INTERMEDIATE_FILE"));
741 auto scanRule = GetScanRule(
742 scanRuleName, ppFileName, scanDepType, vars, responseFlag, flags,
743 rulePlaceholderExpander.get(), this->GetLocalGenerator(),
744 std::move(scanCommands), config);
747 cmStrCat("Rule for generating ", lang, " dependencies.");
748 if (compilationPreprocesses) {
749 scanRule.Description =
750 cmStrCat("Scanning $in for ", lang, " dependencies");
752 scanRule.Description =
753 cmStrCat("Building ", lang, " preprocessed $out");
756 this->GetGlobalGenerator()->AddRule(scanRule);
759 if (!compilationPreprocesses) {
760 // Compilation will not preprocess, so it does not need the defines
761 // unless the compiler wants them for some other purpose.
762 if (!this->CompileWithDefines(lang)) {
766 // Rule to scan dependencies of sources that do not need preprocessing.
767 std::string const& scanRuleName = this->LanguageScanRule(lang, config);
768 std::vector<std::string> scanCommands;
769 scanCommands.emplace_back(
770 GetScanCommand(cmakeCmd, tdi, lang, "$in", "$out"));
773 GetScanRule(scanRuleName, "", scanDepType, vars, "", flags,
774 rulePlaceholderExpander.get(), this->GetLocalGenerator(),
775 std::move(scanCommands), config);
777 // Write the rule for generating dependencies for the given language.
778 scanRule.Comment = cmStrCat("Rule for generating ", lang,
779 " dependencies on non-preprocessed files.");
780 scanRule.Description =
781 cmStrCat("Generating ", lang, " dependencies for $in");
783 this->GetGlobalGenerator()->AddRule(scanRule);
786 // Write the rule for ninja dyndep file generation.
787 cmNinjaRule rule(this->LanguageDyndepRule(lang, config));
788 // Command line length is almost always limited -> use response file for
790 rule.RspFile = "$out.rsp";
791 rule.RspContent = "$in";
793 // Run CMake dependency scanner on the source file (using the preprocessed
794 // source if that was performed).
795 std::string ddModmapArg;
796 if (!modmapFormat.empty()) {
797 ddModmapArg += cmStrCat(" --modmapfmt=", modmapFormat);
800 std::vector<std::string> ddCmds;
802 std::string ccmd = cmStrCat(
803 cmakeCmd, " -E cmake_ninja_dyndep --tdi=", tdi, " --lang=", lang,
804 ddModmapArg, " --dd=$out @", rule.RspFile);
805 ddCmds.emplace_back(std::move(ccmd));
808 this->GetLocalGenerator()->BuildCommandLine(ddCmds, config, config);
811 cmStrCat("Rule to generate ninja dyndep files for ", lang, '.');
812 rule.Description = cmStrCat("Generating ", lang, " dyndep file $out");
813 this->GetGlobalGenerator()->AddRule(rule);
816 cmNinjaRule rule(this->LanguageCompilerRule(lang, config));
817 // If using a response file, move defines, includes, and flags into it.
818 if (!responseFlag.empty()) {
819 rule.RspFile = "$RSP_FILE";
821 cmStrCat(' ', vars.Defines, ' ', vars.Includes, ' ', flags);
822 flags = cmStrCat(responseFlag, rule.RspFile);
827 // Tell ninja dependency format so all deps can be loaded into a database
829 if (!compilationPreprocesses) {
830 // The compiler will not do preprocessing, so it has no such dependencies.
831 } else if (mf->IsOn(cmStrCat("CMAKE_NINJA_CMCLDEPS_", lang))) {
832 // For the MS resource compiler we need cmcldeps, but skip dependencies
833 // for source-file try_compile cases because they are always fresh.
834 if (!mf->GetIsSourceFileTryCompile()) {
835 rule.DepType = "gcc";
836 rule.DepFile = "$DEP_FILE";
837 cmValue d = mf->GetDefinition("CMAKE_C_COMPILER");
838 const std::string cl =
839 d ? *d : mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
840 std::string cmcldepsPath;
841 cmSystemTools::GetShortPath(cmSystemTools::GetCMClDepsCommand(),
843 cldeps = cmStrCat(cmcldepsPath, ' ', lang, ' ', vars.Source,
844 " $DEP_FILE $out \"",
845 mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX"),
849 const auto& depType = this->GetMakefile()->GetSafeDefinition(
850 cmStrCat("CMAKE_", lang, "_DEPFILE_FORMAT"));
851 if (depType == "msvc"_s) {
852 rule.DepType = "msvc";
853 rule.DepFile.clear();
855 rule.DepType = "gcc";
856 rule.DepFile = "$DEP_FILE";
858 vars.DependencyFile = rule.DepFile.c_str();
859 vars.DependencyTarget = "$out";
861 const std::string flagsName = cmStrCat("CMAKE_DEPFILE_FLAGS_", lang);
862 std::string depfileFlags = mf->GetSafeDefinition(flagsName);
863 if (!depfileFlags.empty()) {
864 rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
866 flags += cmStrCat(' ', depfileFlags);
870 if (needDyndep && !modmapFormat.empty()) {
871 std::string modmapFlags = mf->GetRequiredDefinition(
872 cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FLAG"));
873 cmSystemTools::ReplaceString(modmapFlags, "<MODULE_MAP_FILE>",
874 "$DYNDEP_MODULE_MAP_FILE");
875 flags += cmStrCat(' ', modmapFlags);
878 vars.Flags = flags.c_str();
879 vars.DependencyFile = rule.DepFile.c_str();
881 std::string cudaCompileMode;
882 if (lang == "CUDA") {
883 if (this->GeneratorTarget->GetPropertyAsBool(
884 "CUDA_SEPARABLE_COMPILATION")) {
885 const std::string& rdcFlag =
886 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
887 cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
889 if (this->GeneratorTarget->GetPropertyAsBool("CUDA_PTX_COMPILATION")) {
890 const std::string& ptxFlag =
891 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_PTX_FLAG");
892 cudaCompileMode = cmStrCat(cudaCompileMode, ptxFlag);
894 const std::string& wholeFlag =
895 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_WHOLE_FLAG");
896 cudaCompileMode = cmStrCat(cudaCompileMode, wholeFlag);
898 vars.CudaCompileMode = cudaCompileMode.c_str();
901 // Rule for compiling object file.
902 std::vector<std::string> compileCmds;
903 const std::string cmdVar = cmStrCat("CMAKE_", lang, "_COMPILE_OBJECT");
904 const std::string& compileCmd = mf->GetRequiredDefinition(cmdVar);
905 cmExpandList(compileCmd, compileCmds);
907 // See if we need to use a compiler launcher like ccache or distcc
908 std::string compilerLauncher;
909 if (!compileCmds.empty() &&
910 (lang == "C" || lang == "CXX" || lang == "Fortran" || lang == "CUDA" ||
911 lang == "HIP" || lang == "ISPC" || lang == "OBJC" ||
913 std::string const clauncher_prop = cmStrCat(lang, "_COMPILER_LAUNCHER");
914 cmValue clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
915 std::string evaluatedClauncher = cmGeneratorExpression::Evaluate(
916 *clauncher, this->LocalGenerator, config);
917 if (!evaluatedClauncher.empty()) {
918 compilerLauncher = evaluatedClauncher;
922 // Maybe insert an include-what-you-use runner.
923 if (!compileCmds.empty() &&
924 (lang == "C" || lang == "CXX" || lang == "OBJC" || lang == "OBJCXX")) {
925 std::string const tidy_prop = cmStrCat(lang, "_CLANG_TIDY");
926 cmValue tidy = this->GeneratorTarget->GetProperty(tidy_prop);
927 cmValue iwyu = nullptr;
928 cmValue cpplint = nullptr;
929 cmValue cppcheck = nullptr;
930 if (lang == "C" || lang == "CXX") {
931 std::string const iwyu_prop = cmStrCat(lang, "_INCLUDE_WHAT_YOU_USE");
932 iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
933 std::string const cpplint_prop = cmStrCat(lang, "_CPPLINT");
934 cpplint = this->GeneratorTarget->GetProperty(cpplint_prop);
935 std::string const cppcheck_prop = cmStrCat(lang, "_CPPCHECK");
936 cppcheck = this->GeneratorTarget->GetProperty(cppcheck_prop);
938 if (cmNonempty(iwyu) || cmNonempty(tidy) || cmNonempty(cpplint) ||
939 cmNonempty(cppcheck)) {
940 std::string run_iwyu = cmStrCat(cmakeCmd, " -E __run_co_compile");
941 if (!compilerLauncher.empty()) {
942 // In __run_co_compile case the launcher command is supplied
943 // via --launcher=<maybe-list> and consumed
945 cmStrCat(" --launcher=",
946 this->LocalGenerator->EscapeForShell(compilerLauncher));
947 compilerLauncher.clear();
949 if (cmNonempty(iwyu)) {
950 run_iwyu += " --iwyu=";
952 // Only add --driver-mode if it is not already specified, as adding
953 // it unconditionally might override a user-specified driver-mode
954 if (iwyu.Get()->find("--driver-mode=") == std::string::npos) {
955 cmValue p = this->Makefile->GetDefinition(
956 cmStrCat("CMAKE_", lang, "_INCLUDE_WHAT_YOU_USE_DRIVER_MODE"));
957 std::string driverMode;
962 driverMode = lang == "C" ? "gcc" : "g++";
965 run_iwyu += this->LocalGenerator->EscapeForShell(
966 cmStrCat(*iwyu, ";--driver-mode=", driverMode));
968 run_iwyu += this->LocalGenerator->EscapeForShell(*iwyu);
971 if (cmNonempty(tidy)) {
972 run_iwyu += " --tidy=";
973 cmValue p = this->Makefile->GetDefinition(
974 cmStrCat("CMAKE_", lang, "_CLANG_TIDY_DRIVER_MODE"));
975 std::string driverMode;
979 driverMode = lang == "C" ? "gcc" : "g++";
981 run_iwyu += this->GetLocalGenerator()->EscapeForShell(
982 cmStrCat(*tidy, ";--extra-arg-before=--driver-mode=", driverMode));
984 if (cmNonempty(cpplint)) {
985 run_iwyu += cmStrCat(
986 " --cpplint=", this->GetLocalGenerator()->EscapeForShell(*cpplint));
988 if (cmNonempty(cppcheck)) {
990 cmStrCat(" --cppcheck=",
991 this->GetLocalGenerator()->EscapeForShell(*cppcheck));
993 if (cmNonempty(tidy) || cmNonempty(cpplint) || cmNonempty(cppcheck)) {
994 run_iwyu += " --source=$in";
997 compileCmds.front().insert(0, run_iwyu);
1001 // If compiler launcher was specified and not consumed above, it
1002 // goes to the beginning of the command line.
1003 if (!compileCmds.empty() && !compilerLauncher.empty()) {
1004 std::vector<std::string> args = cmExpandedList(compilerLauncher, true);
1005 if (!args.empty()) {
1006 args[0] = this->LocalGenerator->ConvertToOutputFormat(
1007 args[0], cmOutputConverter::SHELL);
1008 for (std::string& i : cmMakeRange(args.begin() + 1, args.end())) {
1009 i = this->LocalGenerator->EscapeForShell(i);
1012 compileCmds.front().insert(0, cmStrCat(cmJoin(args, " "), ' '));
1015 if (!compileCmds.empty()) {
1016 compileCmds.front().insert(0, cldeps);
1019 const auto& extraCommands = this->GetMakefile()->GetSafeDefinition(
1020 cmStrCat("CMAKE_", lang, "_DEPENDS_EXTRA_COMMANDS"));
1021 if (!extraCommands.empty()) {
1022 auto commandList = cmExpandedList(extraCommands);
1023 compileCmds.insert(compileCmds.end(), commandList.cbegin(),
1024 commandList.cend());
1027 for (std::string& i : compileCmds) {
1028 i = cmStrCat(launcher, i);
1029 rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
1034 this->GetLocalGenerator()->BuildCommandLine(compileCmds, config, config);
1036 // Write the rule for compiling file of the given language.
1037 rule.Comment = cmStrCat("Rule for compiling ", lang, " files.");
1038 rule.Description = cmStrCat("Building ", lang, " object $out");
1039 this->GetGlobalGenerator()->AddRule(rule);
1042 void cmNinjaTargetGenerator::WriteObjectBuildStatements(
1043 const std::string& config, const std::string& fileConfig,
1044 bool firstForConfig)
1046 this->GeneratorTarget->CheckCxxModuleStatus(config);
1049 cmGlobalNinjaGenerator::WriteDivider(this->GetImplFileStream(fileConfig));
1050 this->GetImplFileStream(fileConfig)
1051 << "# Object build statements for "
1052 << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
1053 << " target " << this->GetTargetName() << "\n\n";
1056 std::vector<cmSourceFile const*> customCommands;
1057 this->GeneratorTarget->GetCustomCommands(customCommands, config);
1058 for (cmSourceFile const* sf : customCommands) {
1059 cmCustomCommand const* cc = sf->GetCustomCommand();
1060 this->GetLocalGenerator()->AddCustomCommandTarget(
1061 cc, this->GetGeneratorTarget());
1062 // Record the custom commands for this target. The container is used
1063 // in WriteObjectBuildStatement when called in a loop below.
1064 this->Configs[config].CustomCommands.push_back(cc);
1068 std::vector<cmSourceFile const*> headerSources;
1069 this->GeneratorTarget->GetHeaderSources(headerSources, config);
1070 this->OSXBundleGenerator->GenerateMacOSXContentStatements(
1071 headerSources, this->Configs[fileConfig].MacOSXContentGenerator.get(),
1075 std::vector<cmSourceFile const*> extraSources;
1076 this->GeneratorTarget->GetExtraSources(extraSources, config);
1077 this->OSXBundleGenerator->GenerateMacOSXContentStatements(
1078 extraSources, this->Configs[fileConfig].MacOSXContentGenerator.get(),
1081 if (firstForConfig) {
1082 cmValue pchExtension =
1083 this->GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
1085 std::vector<cmSourceFile const*> externalObjects;
1086 this->GeneratorTarget->GetExternalObjects(externalObjects, config);
1087 for (cmSourceFile const* sf : externalObjects) {
1088 auto objectFileName = this->GetGlobalGenerator()->ExpandCFGIntDir(
1089 this->ConvertToNinjaPath(sf->GetFullPath()), config);
1090 if (!cmHasSuffix(objectFileName, pchExtension)) {
1091 this->Configs[config].Objects.push_back(objectFileName);
1097 cmNinjaBuild build("phony");
1099 cmStrCat("Order-only phony target for ", this->GetTargetName());
1100 build.Outputs.push_back(this->OrderDependsTargetForTarget(config));
1102 cmNinjaDeps& orderOnlyDeps = build.OrderOnlyDeps;
1103 this->GetLocalGenerator()->AppendTargetDepends(
1104 this->GeneratorTarget, orderOnlyDeps, config, fileConfig,
1105 DependOnTargetOrdering);
1107 // Add order-only dependencies on other files associated with the target.
1108 cm::append(orderOnlyDeps, this->Configs[config].ExtraFiles);
1110 // Add order-only dependencies on custom command outputs.
1111 for (cmCustomCommand const* cc : this->Configs[config].CustomCommands) {
1112 cmCustomCommandGenerator ccg(*cc, config, this->GetLocalGenerator());
1113 const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
1114 const std::vector<std::string>& ccbyproducts = ccg.GetByproducts();
1115 std::transform(ccoutputs.begin(), ccoutputs.end(),
1116 std::back_inserter(orderOnlyDeps),
1117 this->MapToNinjaPath());
1118 std::transform(ccbyproducts.begin(), ccbyproducts.end(),
1119 std::back_inserter(orderOnlyDeps),
1120 this->MapToNinjaPath());
1123 std::sort(orderOnlyDeps.begin(), orderOnlyDeps.end());
1124 orderOnlyDeps.erase(
1125 std::unique(orderOnlyDeps.begin(), orderOnlyDeps.end()),
1126 orderOnlyDeps.end());
1128 // The phony target must depend on at least one input or ninja will explain
1129 // that "output ... of phony edge with no inputs doesn't exist" and
1130 // consider the phony output "dirty".
1131 if (orderOnlyDeps.empty()) {
1132 // Any path that always exists will work here. It would be nice to
1133 // use just "." but that is not supported by Ninja < 1.7.
1134 std::string tgtDir = cmStrCat(
1135 this->LocalGenerator->GetCurrentBinaryDirectory(), '/',
1136 this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget));
1137 orderOnlyDeps.push_back(this->ConvertToNinjaPath(tgtDir));
1140 this->GetGlobalGenerator()->WriteBuild(this->GetImplFileStream(fileConfig),
1145 std::vector<cmSourceFile const*> objectSources;
1146 this->GeneratorTarget->GetObjectSources(objectSources, config);
1148 for (cmSourceFile const* sf : objectSources) {
1149 this->WriteObjectBuildStatement(sf, config, fileConfig, firstForConfig);
1153 for (auto const& langDDIFiles : this->Configs[config].DDIFiles) {
1154 std::string const& language = langDDIFiles.first;
1155 cmNinjaDeps const& ddiFiles = langDDIFiles.second;
1157 cmNinjaBuild build(this->LanguageDyndepRule(language, config));
1158 build.Outputs.push_back(this->GetDyndepFilePath(language, config));
1159 build.ExplicitDeps = ddiFiles;
1161 this->WriteTargetDependInfo(language, config);
1163 // Make sure dyndep files for all our dependencies have already
1164 // been generated so that the '<LANG>Modules.json' files they
1165 // produced as side-effects are available for us to read.
1166 // Ideally we should depend on the '<LANG>Modules.json' files
1167 // from our dependencies directly, but we don't know which of
1168 // our dependencies produces them. Fixing this will require
1169 // refactoring the Ninja generator to generate targets in
1170 // dependency order so that we can collect the needed information.
1171 this->GetLocalGenerator()->AppendTargetDepends(
1172 this->GeneratorTarget, build.OrderOnlyDeps, config, fileConfig,
1173 DependOnTargetArtifact);
1175 this->GetGlobalGenerator()->WriteBuild(this->GetImplFileStream(fileConfig),
1179 this->GetImplFileStream(fileConfig) << "\n";
1181 if (!this->Configs[config].SwiftOutputMap.empty()) {
1182 std::string const mapFilePath =
1183 cmStrCat(this->GeneratorTarget->GetSupportDirectory(), '/', config, '/',
1184 "output-file-map.json");
1185 std::string const targetSwiftDepsPath = [this, config]() -> std::string {
1186 cmGeneratorTarget const* target = this->GeneratorTarget;
1187 if (cmValue name = target->GetProperty("Swift_DEPENDENCIES_FILE")) {
1190 return this->ConvertToNinjaPath(
1191 cmStrCat(target->GetSupportDirectory(), '/', config, '/',
1192 target->GetName(), ".swiftdeps"));
1195 // build the global target dependencies
1196 // https://github.com/apple/swift/blob/master/docs/Driver.md#output-file-maps
1197 Json::Value deps(Json::objectValue);
1198 deps["swift-dependencies"] = targetSwiftDepsPath;
1199 this->Configs[config].SwiftOutputMap[""] = deps;
1201 cmGeneratedFileStream output(mapFilePath);
1202 output << this->Configs[config].SwiftOutputMap;
1207 cmNinjaBuild GetScanBuildStatement(const std::string& ruleName,
1208 const std::string& ppFileName,
1209 bool compilePP, bool compilePPWithDefines,
1210 cmNinjaBuild& objBuild, cmNinjaVars& vars,
1211 std::string const& modmapFormat,
1212 const std::string& objectFileName,
1213 cmLocalGenerator* lg)
1215 cmNinjaBuild scanBuild(ruleName);
1217 scanBuild.RspFile = "$out.rsp";
1220 // Move compilation dependencies to the scan/preprocessing build statement.
1221 std::swap(scanBuild.ExplicitDeps, objBuild.ExplicitDeps);
1222 std::swap(scanBuild.ImplicitDeps, objBuild.ImplicitDeps);
1223 std::swap(scanBuild.OrderOnlyDeps, objBuild.OrderOnlyDeps);
1224 std::swap(scanBuild.Variables["IN_ABS"], vars["IN_ABS"]);
1226 // The actual compilation will now use the preprocessed source.
1227 objBuild.ExplicitDeps.push_back(ppFileName);
1229 // Copy compilation dependencies to the scan/preprocessing build statement.
1230 scanBuild.ExplicitDeps = objBuild.ExplicitDeps;
1231 scanBuild.ImplicitDeps = objBuild.ImplicitDeps;
1232 scanBuild.OrderOnlyDeps = objBuild.OrderOnlyDeps;
1233 scanBuild.Variables["IN_ABS"] = vars["IN_ABS"];
1236 // Scanning and compilation generally use the same flags.
1237 scanBuild.Variables["FLAGS"] = vars["FLAGS"];
1239 if (compilePP && !compilePPWithDefines) {
1240 // Move preprocessor definitions to the scan/preprocessor build statement.
1241 std::swap(scanBuild.Variables["DEFINES"], vars["DEFINES"]);
1243 // Copy preprocessor definitions to the scan/preprocessor build statement.
1244 scanBuild.Variables["DEFINES"] = vars["DEFINES"];
1247 // Copy include directories to the preprocessor build statement. The
1248 // Fortran compilation build statement still needs them for the INCLUDE
1250 scanBuild.Variables["INCLUDES"] = vars["INCLUDES"];
1252 // Tell dependency scanner the object file that will result from
1253 // compiling the source.
1254 scanBuild.Variables["OBJ_FILE"] = objectFileName;
1256 // Tell dependency scanner where to store dyndep intermediate results.
1257 std::string const& ddiFile = cmStrCat(objectFileName, ".ddi");
1258 scanBuild.Variables["DYNDEP_INTERMEDIATE_FILE"] = ddiFile;
1260 // Outputs of the scan/preprocessor build statement.
1262 scanBuild.Outputs.push_back(ppFileName);
1263 scanBuild.ImplicitOuts.push_back(ddiFile);
1265 scanBuild.Outputs.push_back(ddiFile);
1266 scanBuild.Variables["PREPROCESSED_OUTPUT_FILE"] = ppFileName;
1269 // Scanning always provides a depfile for preprocessor dependencies. This
1270 // variable is unused in `msvc`-deptype scanners.
1271 std::string const& depFileName = cmStrCat(scanBuild.Outputs.front(), ".d");
1272 scanBuild.Variables["DEP_FILE"] =
1273 lg->ConvertToOutputFormat(depFileName, cmOutputConverter::SHELL);
1275 // The actual compilation does not need a depfile because it
1276 // depends on the already-preprocessed source.
1277 vars.erase("DEP_FILE");
1280 if (!modmapFormat.empty()) {
1281 // XXX(modmap): If changing this path construction, change
1282 // `cmGlobalNinjaGenerator::WriteDyndep` to expect the corresponding
1284 std::string const ddModmapFile = cmStrCat(objectFileName, ".modmap");
1285 scanBuild.Variables["DYNDEP_MODULE_MAP_FILE"] = ddModmapFile;
1286 scanBuild.ImplicitOuts.push_back(ddModmapFile);
1293 void cmNinjaTargetGenerator::WriteObjectBuildStatement(
1294 cmSourceFile const* source, const std::string& config,
1295 const std::string& fileConfig, bool firstForConfig)
1297 std::string const language = source->GetLanguage();
1298 std::string const sourceFilePath = this->GetCompiledSourceNinjaPath(source);
1299 std::string const objectDir = this->ConvertToNinjaPath(
1300 cmStrCat(this->GeneratorTarget->GetSupportDirectory(),
1301 this->GetGlobalGenerator()->ConfigDirectory(config)));
1302 std::string const objectFileName =
1303 this->ConvertToNinjaPath(this->GetObjectFilePath(source, config));
1304 std::string const objectFileDir =
1305 cmSystemTools::GetFilenamePath(objectFileName);
1307 std::string cmakeVarLang = cmStrCat("CMAKE_", language);
1309 // build response file name
1310 std::string cmakeLinkVar = cmStrCat(cmakeVarLang, "_RESPONSE_FILE_FLAG");
1312 cmValue flag = this->GetMakefile()->GetDefinition(cmakeLinkVar);
1314 bool const lang_supports_response =
1315 !(language == "RC" || (language == "CUDA" && !flag));
1316 int const commandLineLengthLimit =
1317 ((lang_supports_response && this->ForceResponseFile())) ? -1 : 0;
1319 cmNinjaBuild objBuild(this->LanguageCompilerRule(language, config));
1320 cmNinjaVars& vars = objBuild.Variables;
1321 vars["FLAGS"] = this->ComputeFlagsForObject(source, language, config);
1322 vars["DEFINES"] = this->ComputeDefines(source, language, config);
1323 vars["INCLUDES"] = this->ComputeIncludes(source, language, config);
1325 if (this->GetMakefile()->GetSafeDefinition(
1326 cmStrCat("CMAKE_", language, "_DEPFILE_FORMAT")) != "msvc"_s) {
1327 bool replaceExt(false);
1328 if (!language.empty()) {
1329 std::string repVar =
1330 cmStrCat("CMAKE_", language, "_DEPFILE_EXTENSION_REPLACE");
1331 replaceExt = this->Makefile->IsOn(repVar);
1334 // use original code
1335 vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
1336 cmStrCat(objectFileName, ".d"), cmOutputConverter::SHELL);
1338 // Replace the original source file extension with the
1339 // depend file extension.
1340 std::string dependFileName = cmStrCat(
1341 cmSystemTools::GetFilenameWithoutLastExtension(objectFileName), ".d");
1342 vars["DEP_FILE"] = this->GetLocalGenerator()->ConvertToOutputFormat(
1343 cmStrCat(objectFileDir, '/', dependFileName),
1344 cmOutputConverter::SHELL);
1348 if (firstForConfig) {
1349 this->ExportObjectCompileCommand(
1350 language, sourceFilePath, objectDir, objectFileName, objectFileDir,
1351 vars["FLAGS"], vars["DEFINES"], vars["INCLUDES"], config);
1354 objBuild.Outputs.push_back(objectFileName);
1355 if (firstForConfig) {
1356 cmValue pchExtension =
1357 this->GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
1358 if (!cmHasSuffix(objectFileName, pchExtension)) {
1359 // Add this object to the list of object files.
1360 this->Configs[config].Objects.push_back(objectFileName);
1364 objBuild.ExplicitDeps.push_back(sourceFilePath);
1366 // Add precompile headers dependencies
1367 std::vector<std::string> depList;
1369 std::vector<std::string> architectures;
1370 this->GeneratorTarget->GetAppleArchs(config, architectures);
1371 if (architectures.empty()) {
1372 architectures.emplace_back();
1375 std::unordered_set<std::string> pchSources;
1376 for (const std::string& arch : architectures) {
1377 const std::string pchSource =
1378 this->GeneratorTarget->GetPchSource(config, language, arch);
1380 if (!pchSource.empty()) {
1381 pchSources.insert(pchSource);
1385 if (!pchSources.empty() && !source->GetProperty("SKIP_PRECOMPILE_HEADERS")) {
1386 for (const std::string& arch : architectures) {
1388 this->GeneratorTarget->GetPchHeader(config, language, arch));
1389 if (pchSources.find(source->GetFullPath()) == pchSources.end()) {
1391 this->GeneratorTarget->GetPchFile(config, language, arch));
1396 if (cmValue objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
1397 std::vector<std::string> objDepList = cmExpandedList(*objectDeps);
1398 std::copy(objDepList.begin(), objDepList.end(),
1399 std::back_inserter(depList));
1402 if (!depList.empty()) {
1403 for (std::string& odi : depList) {
1404 if (cmSystemTools::FileIsFullPath(odi)) {
1405 odi = cmSystemTools::CollapseFullPath(odi);
1408 std::transform(depList.begin(), depList.end(),
1409 std::back_inserter(objBuild.ImplicitDeps),
1410 this->MapToNinjaPath());
1413 objBuild.OrderOnlyDeps.push_back(this->OrderDependsTargetForTarget(config));
1415 // If the source file is GENERATED and does not have a custom command
1416 // (either attached to this source file or another one), assume that one of
1417 // the target dependencies, OBJECT_DEPENDS or header file custom commands
1418 // will rebuild the file.
1419 if (source->GetIsGenerated() &&
1420 !source->GetPropertyAsBool("__CMAKE_GENERATED_BY_CMAKE") &&
1421 !source->GetCustomCommand() &&
1422 !this->GetGlobalGenerator()->HasCustomCommandOutput(sourceFilePath)) {
1423 this->GetGlobalGenerator()->AddAssumedSourceDependencies(
1424 sourceFilePath, objBuild.OrderOnlyDeps);
1427 // For some cases we scan to dynamically discover dependencies.
1428 bool const needDyndep = this->NeedDyndep(language, config);
1429 bool const compilationPreprocesses =
1430 !this->NeedExplicitPreprocessing(language);
1432 std::string modmapFormat;
1434 std::string const modmapFormatVar =
1435 cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FORMAT");
1436 modmapFormat = this->Makefile->GetSafeDefinition(modmapFormatVar);
1440 // If source/target has preprocessing turned off, we still need to
1441 // generate an explicit dependency step
1442 const auto srcpp = source->GetSafeProperty("Fortran_PREPROCESS");
1443 cmOutputConverter::FortranPreprocess preprocess =
1444 cmOutputConverter::GetFortranPreprocess(srcpp);
1445 if (preprocess == cmOutputConverter::FortranPreprocess::Unset) {
1447 this->GeneratorTarget->GetSafeProperty("Fortran_PREPROCESS");
1448 preprocess = cmOutputConverter::GetFortranPreprocess(tgtpp);
1451 bool const compilePP = !compilationPreprocesses &&
1452 (preprocess != cmOutputConverter::FortranPreprocess::NotNeeded);
1453 bool const compilePPWithDefines =
1454 compilePP && this->CompileWithDefines(language);
1456 std::string scanRuleName;
1457 std::string ppFileName;
1459 scanRuleName = this->LanguagePreprocessAndScanRule(language, config);
1460 ppFileName = this->ConvertToNinjaPath(
1461 this->GetPreprocessedFilePath(source, config));
1463 scanRuleName = this->LanguageScanRule(language, config);
1464 ppFileName = cmStrCat(objectFileName, ".ddi.i");
1467 cmNinjaBuild ppBuild = GetScanBuildStatement(
1468 scanRuleName, ppFileName, compilePP, compilePPWithDefines, objBuild,
1469 vars, modmapFormat, objectFileName, this->LocalGenerator);
1472 // In case compilation requires flags that are incompatible with
1473 // preprocessing, include them here.
1474 std::string const& postFlag = this->Makefile->GetSafeDefinition(
1475 cmStrCat("CMAKE_", language, "_POSTPROCESS_FLAG"));
1476 this->LocalGenerator->AppendFlags(vars["FLAGS"], postFlag);
1478 // Prepend source file's original directory as an include directory
1479 // so e.g. Fortran INCLUDE statements can look for files in it.
1480 std::vector<std::string> sourceDirectory;
1481 sourceDirectory.push_back(
1482 cmSystemTools::GetParentDirectory(source->GetFullPath()));
1484 std::string sourceDirectoryFlag = this->LocalGenerator->GetIncludeFlags(
1485 sourceDirectory, this->GeneratorTarget, language, config, false);
1487 vars["INCLUDES"] = cmStrCat(sourceDirectoryFlag, ' ', vars["INCLUDES"]);
1490 if (firstForConfig) {
1491 std::string const ddiFile = cmStrCat(objectFileName, ".ddi");
1492 this->Configs[config].DDIFiles[language].push_back(ddiFile);
1495 this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
1498 this->GetGlobalGenerator()->WriteBuild(this->GetImplFileStream(fileConfig),
1499 ppBuild, commandLineLengthLimit);
1501 std::string const dyndep = this->GetDyndepFilePath(language, config);
1502 objBuild.OrderOnlyDeps.push_back(dyndep);
1503 vars["dyndep"] = dyndep;
1505 if (!modmapFormat.empty()) {
1506 std::string const ddModmapFile = cmStrCat(objectFileName, ".modmap");
1507 vars["DYNDEP_MODULE_MAP_FILE"] = ddModmapFile;
1508 objBuild.OrderOnlyDeps.push_back(ddModmapFile);
1512 this->EnsureParentDirectoryExists(objectFileName);
1514 vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
1515 objectDir, cmOutputConverter::SHELL);
1516 vars["OBJECT_FILE_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
1517 objectFileDir, cmOutputConverter::SHELL);
1519 this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
1522 if (!pchSources.empty() && !source->GetProperty("SKIP_PRECOMPILE_HEADERS")) {
1523 auto pchIt = pchSources.find(source->GetFullPath());
1524 if (pchIt != pchSources.end()) {
1525 this->addPoolNinjaVariable("JOB_POOL_PRECOMPILE_HEADER",
1526 this->GetGeneratorTarget(), vars);
1530 this->SetMsvcTargetPdbVariable(vars, config);
1532 objBuild.RspFile = cmStrCat(objectFileName, ".rsp");
1534 if (language == "ISPC") {
1535 std::string const& objectName =
1536 this->GeneratorTarget->GetObjectName(source);
1537 std::string ispcSource =
1538 cmSystemTools::GetFilenameWithoutLastExtension(objectName);
1539 ispcSource = cmSystemTools::GetFilenameWithoutLastExtension(ispcSource);
1541 cmValue ispcSuffixProp =
1542 this->GeneratorTarget->GetProperty("ISPC_HEADER_SUFFIX");
1543 assert(ispcSuffixProp);
1545 std::string ispcHeaderDirectory =
1546 this->GeneratorTarget->GetObjectDirectory(config);
1548 this->GeneratorTarget->GetProperty("ISPC_HEADER_DIRECTORY")) {
1549 ispcHeaderDirectory =
1550 cmStrCat(this->LocalGenerator->GetBinaryDirectory(), '/', *prop);
1553 std::string ispcHeader =
1554 cmStrCat(ispcHeaderDirectory, '/', ispcSource, *ispcSuffixProp);
1555 ispcHeader = this->ConvertToNinjaPath(ispcHeader);
1557 // Make sure ninja knows what command generates the header
1558 objBuild.ImplicitOuts.push_back(ispcHeader);
1560 // Make sure ninja knows how to clean the generated header
1561 this->GetGlobalGenerator()->AddAdditionalCleanFile(ispcHeader, config);
1564 detail::ComputeISPCObjectSuffixes(this->GeneratorTarget);
1565 if (ispcSuffixes.size() > 1) {
1566 std::string rootObjectDir =
1567 this->GeneratorTarget->GetObjectDirectory(config);
1568 auto ispcSideEfffectObjects = detail::ComputeISPCExtraObjects(
1569 objectName, rootObjectDir, ispcSuffixes);
1571 for (auto sideEffect : ispcSideEfffectObjects) {
1572 sideEffect = this->ConvertToNinjaPath(sideEffect);
1573 objBuild.ImplicitOuts.emplace_back(sideEffect);
1574 this->GetGlobalGenerator()->AddAdditionalCleanFile(sideEffect, config);
1578 vars["ISPC_HEADER_FILE"] =
1579 this->GetLocalGenerator()->ConvertToOutputFormat(
1580 ispcHeader, cmOutputConverter::SHELL);
1582 auto headers = this->GeneratorTarget->GetGeneratedISPCHeaders(config);
1583 if (!headers.empty()) {
1584 std::transform(headers.begin(), headers.end(), headers.begin(),
1585 this->MapToNinjaPath());
1586 objBuild.OrderOnlyDeps.insert(objBuild.OrderOnlyDeps.end(),
1587 headers.begin(), headers.end());
1591 if (language == "Swift") {
1592 this->EmitSwiftDependencyInfo(source, config);
1594 this->GetGlobalGenerator()->WriteBuild(this->GetImplFileStream(fileConfig),
1595 objBuild, commandLineLengthLimit);
1598 if (cmValue objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
1599 std::string evaluatedObjectOutputs = cmGeneratorExpression::Evaluate(
1600 *objectOutputs, this->LocalGenerator, config);
1602 if (!evaluatedObjectOutputs.empty()) {
1603 cmNinjaBuild build("phony");
1604 build.Comment = "Additional output files.";
1605 build.Outputs = cmExpandedList(evaluatedObjectOutputs);
1606 std::transform(build.Outputs.begin(), build.Outputs.end(),
1607 build.Outputs.begin(), this->MapToNinjaPath());
1608 build.ExplicitDeps = objBuild.Outputs;
1609 this->GetGlobalGenerator()->WriteBuild(
1610 this->GetImplFileStream(fileConfig), build);
1615 void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang,
1616 const std::string& config)
1618 Json::Value tdi(Json::objectValue);
1619 tdi["language"] = lang;
1620 tdi["compiler-id"] = this->Makefile->GetSafeDefinition(
1621 cmStrCat("CMAKE_", lang, "_COMPILER_ID"));
1623 std::string mod_dir;
1624 if (lang == "Fortran") {
1625 mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(
1626 this->Makefile->GetHomeOutputDirectory());
1627 } else if (lang == "CXX") {
1628 mod_dir = this->GetGlobalGenerator()->ExpandCFGIntDir(
1629 cmSystemTools::CollapseFullPath(this->GeneratorTarget->ObjectDirectory),
1632 if (mod_dir.empty()) {
1633 mod_dir = this->Makefile->GetCurrentBinaryDirectory();
1635 tdi["module-dir"] = mod_dir;
1637 if (lang == "Fortran") {
1638 tdi["submodule-sep"] =
1639 this->Makefile->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_SEP");
1640 tdi["submodule-ext"] =
1641 this->Makefile->GetSafeDefinition("CMAKE_Fortran_SUBMODULE_EXT");
1642 } else if (lang == "CXX") {
1643 // No extra information necessary.
1646 tdi["dir-cur-bld"] = this->Makefile->GetCurrentBinaryDirectory();
1647 tdi["dir-cur-src"] = this->Makefile->GetCurrentSourceDirectory();
1648 tdi["dir-top-bld"] = this->Makefile->GetHomeOutputDirectory();
1649 tdi["dir-top-src"] = this->Makefile->GetHomeDirectory();
1651 Json::Value& tdi_include_dirs = tdi["include-dirs"] = Json::arrayValue;
1652 std::vector<std::string> includes;
1653 this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
1655 for (std::string const& i : includes) {
1656 // Convert the include directories the same way we do for -I flags.
1657 // See upstream ninja issue 1251.
1658 tdi_include_dirs.append(this->ConvertToNinjaPath(i));
1661 Json::Value& tdi_linked_target_dirs = tdi["linked-target-dirs"] =
1663 for (std::string const& l : this->GetLinkedTargetDirectories(config)) {
1664 tdi_linked_target_dirs.append(l);
1667 cmTarget* tgt = this->GeneratorTarget->Target;
1668 auto all_file_sets = tgt->GetAllFileSetNames();
1669 Json::Value& tdi_cxx_module_info = tdi["cxx-modules"] = Json::objectValue;
1670 for (auto const& file_set_name : all_file_sets) {
1671 auto* file_set = tgt->GetFileSet(file_set_name);
1673 this->GetMakefile()->IssueMessage(
1674 MessageType::INTERNAL_ERROR,
1675 cmStrCat("Target \"", tgt->GetName(),
1676 "\" is tracked to have file set \"", file_set_name,
1677 "\", but it was not found."));
1680 auto fs_type = file_set->GetType();
1681 // We only care about C++ module sources here.
1682 if (fs_type != "CXX_MODULES"_s) {
1686 auto fileEntries = file_set->CompileFileEntries();
1687 auto directoryEntries = file_set->CompileDirectoryEntries();
1689 auto directories = file_set->EvaluateDirectoryEntries(
1690 directoryEntries, this->GeneratorTarget->LocalGenerator, config,
1691 this->GeneratorTarget);
1692 std::map<std::string, std::vector<std::string>> files_per_dirs;
1693 for (auto const& entry : fileEntries) {
1694 file_set->EvaluateFileEntry(directories, files_per_dirs, entry,
1695 this->GeneratorTarget->LocalGenerator,
1696 config, this->GeneratorTarget);
1699 std::map<std::string, cmSourceFile const*> sf_map;
1701 std::vector<cmSourceFile const*> objectSources;
1702 this->GeneratorTarget->GetObjectSources(objectSources, config);
1703 for (auto const* sf : objectSources) {
1704 auto full_path = sf->GetFullPath();
1705 if (full_path.empty()) {
1706 this->GetMakefile()->IssueMessage(
1707 MessageType::INTERNAL_ERROR,
1708 cmStrCat("Target \"", tgt->GetName(),
1709 "\" has a full path-less source file."));
1712 sf_map[full_path] = sf;
1716 Json::Value fs_dest = Json::nullValue;
1717 for (auto const& ig : this->GetMakefile()->GetInstallGenerators()) {
1718 if (auto const* fsg =
1719 dynamic_cast<cmInstallFileSetGenerator const*>(ig.get())) {
1720 if (fsg->GetTarget() == this->GeneratorTarget &&
1721 fsg->GetFileSet() == file_set) {
1722 fs_dest = fsg->GetDestination(config);
1728 for (auto const& files_per_dir : files_per_dirs) {
1729 for (auto const& file : files_per_dir.second) {
1730 auto lookup = sf_map.find(file);
1731 if (lookup == sf_map.end()) {
1732 this->GetMakefile()->IssueMessage(
1733 MessageType::INTERNAL_ERROR,
1734 cmStrCat("Target \"", tgt->GetName(), "\" has source file \"",
1736 R"(" which is not in any of its "FILE_SET BASE_DIRS".)"));
1740 auto const* sf = lookup->second;
1743 this->GetMakefile()->IssueMessage(
1744 MessageType::INTERNAL_ERROR,
1745 cmStrCat("Target \"", tgt->GetName(), "\" has source file \"",
1746 file, "\" which has not been tracked properly."));
1750 auto obj_path = this->GetObjectFilePath(sf, config);
1751 Json::Value& tdi_module_info = tdi_cxx_module_info[obj_path] =
1754 tdi_module_info["source"] = file;
1755 tdi_module_info["relative-directory"] = files_per_dir.first;
1756 tdi_module_info["name"] = file_set->GetName();
1757 tdi_module_info["type"] = file_set->GetType();
1758 tdi_module_info["visibility"] =
1759 std::string(cmFileSetVisibilityToName(file_set->GetVisibility()));
1760 tdi_module_info["destination"] = fs_dest;
1765 tdi["config"] = config;
1767 // Add information about the export sets that this target is a member of.
1768 Json::Value& tdi_exports = tdi["exports"] = Json::arrayValue;
1769 std::string export_name = this->GeneratorTarget->GetExportName();
1771 cmInstallCxxModuleBmiGenerator const* bmi_gen = nullptr;
1772 for (auto const& ig : this->GetMakefile()->GetInstallGenerators()) {
1773 if (auto const* bmig =
1774 dynamic_cast<cmInstallCxxModuleBmiGenerator const*>(ig.get())) {
1775 if (bmig->GetTarget() == this->GeneratorTarget) {
1782 Json::Value tdi_bmi_info = Json::objectValue;
1784 tdi_bmi_info["permissions"] = bmi_gen->GetFilePermissions();
1785 tdi_bmi_info["destination"] = bmi_gen->GetDestination(config);
1786 const char* msg_level = "";
1787 switch (bmi_gen->GetMessageLevel()) {
1788 case cmInstallGenerator::MessageDefault:
1790 case cmInstallGenerator::MessageAlways:
1791 msg_level = "MESSAGE_ALWAYS";
1793 case cmInstallGenerator::MessageLazy:
1794 msg_level = "MESSAGE_LAZY";
1796 case cmInstallGenerator::MessageNever:
1797 msg_level = "MESSAGE_NEVER";
1800 tdi_bmi_info["message-level"] = msg_level;
1801 tdi_bmi_info["script-location"] = bmi_gen->GetScriptLocation(config);
1803 tdi["bmi-installation"] = tdi_bmi_info;
1805 tdi["bmi-installation"] = Json::nullValue;
1808 auto const& all_install_exports =
1809 this->GetGlobalGenerator()->GetExportSets();
1810 for (auto const& exp : all_install_exports) {
1811 // Ignore exports sets which are not for this target.
1812 auto const& targets = exp.second.GetTargetExports();
1814 std::find_if(targets.begin(), targets.end(),
1815 [this](std::unique_ptr<cmTargetExport> const& te) {
1816 return te->Target == this->GeneratorTarget;
1818 if (tgt_export == targets.end()) {
1822 auto const* installs = exp.second.GetInstallations();
1823 for (auto const* install : *installs) {
1824 Json::Value tdi_export_info = Json::objectValue;
1826 auto const& ns = install->GetNamespace();
1827 auto const& dest = install->GetDestination();
1828 auto const& cxxm_dir = install->GetCxxModuleDirectory();
1829 auto const& export_prefix = install->GetTempDir();
1831 tdi_export_info["namespace"] = ns;
1832 tdi_export_info["export-name"] = export_name;
1833 tdi_export_info["destination"] = dest;
1834 tdi_export_info["cxx-module-info-dir"] = cxxm_dir;
1835 tdi_export_info["export-prefix"] = export_prefix;
1836 tdi_export_info["install"] = true;
1838 tdi_exports.append(tdi_export_info);
1842 auto const& all_build_exports =
1843 this->GetMakefile()->GetExportBuildFileGenerators();
1844 for (auto const& exp : all_build_exports) {
1845 std::vector<std::string> targets;
1846 exp->GetTargets(targets);
1848 // Ignore exports sets which are not for this target.
1849 auto const& name = this->GeneratorTarget->GetName();
1850 bool has_current_target =
1851 std::any_of(targets.begin(), targets.end(),
1852 [name](std::string const& tname) { return tname == name; });
1853 if (!has_current_target) {
1857 Json::Value tdi_export_info = Json::objectValue;
1859 auto const& ns = exp->GetNamespace();
1860 auto const& main_fn = exp->GetMainExportFileName();
1861 auto const& cxxm_dir = exp->GetCxxModuleDirectory();
1862 auto dest = cmsys::SystemTools::GetParentDirectory(main_fn);
1863 auto const& export_prefix =
1864 cmSystemTools::GetFilenamePath(exp->GetMainExportFileName());
1866 tdi_export_info["namespace"] = ns;
1867 tdi_export_info["export-name"] = export_name;
1868 tdi_export_info["destination"] = dest;
1869 tdi_export_info["cxx-module-info-dir"] = cxxm_dir;
1870 tdi_export_info["export-prefix"] = export_prefix;
1871 tdi_export_info["install"] = false;
1873 tdi_exports.append(tdi_export_info);
1876 std::string const tdin = this->GetTargetDependInfoPath(lang, config);
1877 cmGeneratedFileStream tdif(tdin);
1881 void cmNinjaTargetGenerator::EmitSwiftDependencyInfo(
1882 cmSourceFile const* source, const std::string& config)
1884 std::string const sourceFilePath = this->GetCompiledSourceNinjaPath(source);
1885 std::string const objectFilePath =
1886 this->ConvertToNinjaPath(this->GetObjectFilePath(source, config));
1887 std::string const swiftDepsPath = [source, objectFilePath]() -> std::string {
1888 if (cmValue name = source->GetProperty("Swift_DEPENDENCIES_FILE")) {
1891 return cmStrCat(objectFilePath, ".swiftdeps");
1893 std::string const swiftDiaPath = [source, objectFilePath]() -> std::string {
1894 if (cmValue name = source->GetProperty("Swift_DIAGNOSTICS_FILE")) {
1897 return cmStrCat(objectFilePath, ".dia");
1899 std::string const makeDepsPath = [this, source, config]() -> std::string {
1900 cmLocalNinjaGenerator const* local = this->GetLocalGenerator();
1901 std::string const objectFileName =
1902 this->ConvertToNinjaPath(this->GetObjectFilePath(source, config));
1903 std::string const objectFileDir =
1904 cmSystemTools::GetFilenamePath(objectFileName);
1906 if (this->Makefile->IsOn("CMAKE_Swift_DEPFLE_EXTNSION_REPLACE")) {
1907 std::string dependFileName = cmStrCat(
1908 cmSystemTools::GetFilenameWithoutLastExtension(objectFileName), ".d");
1909 return local->ConvertToOutputFormat(
1910 cmStrCat(objectFileDir, '/', dependFileName),
1911 cmOutputConverter::SHELL);
1913 return local->ConvertToOutputFormat(cmStrCat(objectFileName, ".d"),
1914 cmOutputConverter::SHELL);
1917 // build the source file mapping
1918 // https://github.com/apple/swift/blob/master/docs/Driver.md#output-file-maps
1919 Json::Value entry = Json::Value(Json::objectValue);
1920 entry["object"] = objectFilePath;
1921 entry["dependencies"] = makeDepsPath;
1922 entry["swift-dependencies"] = swiftDepsPath;
1923 entry["diagnostics"] = swiftDiaPath;
1924 this->Configs[config].SwiftOutputMap[sourceFilePath] = entry;
1927 void cmNinjaTargetGenerator::ExportObjectCompileCommand(
1928 std::string const& language, std::string const& sourceFileName,
1929 std::string const& objectDir, std::string const& objectFileName,
1930 std::string const& objectFileDir, std::string const& flags,
1931 std::string const& defines, std::string const& includes,
1932 std::string const& outputConfig)
1934 if (!this->GeneratorTarget->GetPropertyAsBool("EXPORT_COMPILE_COMMANDS")) {
1938 cmRulePlaceholderExpander::RuleVariables compileObjectVars;
1939 compileObjectVars.Language = language.c_str();
1941 std::string escapedSourceFileName = sourceFileName;
1943 if (!cmSystemTools::FileIsFullPath(sourceFileName)) {
1944 escapedSourceFileName =
1945 cmSystemTools::CollapseFullPath(escapedSourceFileName,
1946 this->GetGlobalGenerator()
1947 ->GetCMakeInstance()
1948 ->GetHomeOutputDirectory());
1951 escapedSourceFileName = this->LocalGenerator->ConvertToOutputFormat(
1952 escapedSourceFileName, cmOutputConverter::SHELL);
1954 compileObjectVars.Source = escapedSourceFileName.c_str();
1955 compileObjectVars.Object = objectFileName.c_str();
1956 compileObjectVars.ObjectDir = objectDir.c_str();
1957 compileObjectVars.ObjectFileDir = objectFileDir.c_str();
1958 compileObjectVars.Flags = flags.c_str();
1959 compileObjectVars.Defines = defines.c_str();
1960 compileObjectVars.Includes = includes.c_str();
1962 // Rule for compiling object file.
1963 std::string cudaCompileMode;
1964 if (language == "CUDA") {
1965 if (this->GeneratorTarget->GetPropertyAsBool(
1966 "CUDA_SEPARABLE_COMPILATION")) {
1967 const std::string& rdcFlag =
1968 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
1969 cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
1971 if (this->GeneratorTarget->GetPropertyAsBool("CUDA_PTX_COMPILATION")) {
1972 const std::string& ptxFlag =
1973 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_PTX_FLAG");
1974 cudaCompileMode = cmStrCat(cudaCompileMode, ptxFlag);
1976 const std::string& wholeFlag =
1977 this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_WHOLE_FLAG");
1978 cudaCompileMode = cmStrCat(cudaCompileMode, wholeFlag);
1980 compileObjectVars.CudaCompileMode = cudaCompileMode.c_str();
1983 std::vector<std::string> compileCmds;
1984 const std::string cmdVar = cmStrCat("CMAKE_", language, "_COMPILE_OBJECT");
1985 const std::string& compileCmd =
1986 this->Makefile->GetRequiredDefinition(cmdVar);
1987 cmExpandList(compileCmd, compileCmds);
1989 std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
1990 this->GetLocalGenerator()->CreateRulePlaceholderExpander());
1992 for (std::string& i : compileCmds) {
1993 // no launcher for CMAKE_EXPORT_COMPILE_COMMANDS
1994 rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
1998 std::string cmdLine = this->GetLocalGenerator()->BuildCommandLine(
1999 compileCmds, outputConfig, outputConfig);
2001 this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine, sourceFileName);
2004 void cmNinjaTargetGenerator::AdditionalCleanFiles(const std::string& config)
2006 if (cmValue prop_value =
2007 this->GeneratorTarget->GetProperty("ADDITIONAL_CLEAN_FILES")) {
2008 cmLocalNinjaGenerator* lg = this->LocalGenerator;
2009 std::vector<std::string> cleanFiles;
2010 cmExpandList(cmGeneratorExpression::Evaluate(*prop_value, lg, config,
2011 this->GeneratorTarget),
2013 std::string const& binaryDir = lg->GetCurrentBinaryDirectory();
2014 cmGlobalNinjaGenerator* gg = lg->GetGlobalNinjaGenerator();
2015 for (std::string const& cleanFile : cleanFiles) {
2016 // Support relative paths
2017 gg->AddAdditionalCleanFile(
2018 cmSystemTools::CollapseFullPath(cleanFile, binaryDir), config);
2023 cmNinjaDeps cmNinjaTargetGenerator::GetObjects(const std::string& config) const
2025 auto const it = this->Configs.find(config);
2026 if (it != this->Configs.end()) {
2027 return it->second.Objects;
2032 void cmNinjaTargetGenerator::EnsureDirectoryExists(
2033 const std::string& path) const
2035 if (cmSystemTools::FileIsFullPath(path)) {
2036 cmSystemTools::MakeDirectory(path);
2038 cmGlobalNinjaGenerator* gg = this->GetGlobalGenerator();
2039 std::string fullPath = gg->GetCMakeInstance()->GetHomeOutputDirectory();
2040 // Also ensures there is a trailing slash.
2041 gg->StripNinjaOutputPathPrefixAsSuffix(fullPath);
2043 cmSystemTools::MakeDirectory(fullPath);
2047 void cmNinjaTargetGenerator::EnsureParentDirectoryExists(
2048 const std::string& path) const
2050 this->EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
2053 void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
2054 cmSourceFile const& source, const char* pkgloc, const std::string& config)
2056 // Skip OS X content when not building a Framework or Bundle.
2057 if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
2061 std::string macdir =
2062 this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc,
2065 // Reject files that collide with files from the Ninja file's native config.
2066 if (config != this->FileConfig) {
2067 std::string nativeMacdir =
2068 this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(
2069 pkgloc, this->FileConfig);
2070 if (macdir == nativeMacdir) {
2075 // Get the input file location.
2076 std::string input = source.GetFullPath();
2077 input = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input);
2079 // Get the output file location.
2080 std::string output =
2081 cmStrCat(macdir, '/', cmSystemTools::GetFilenameName(input));
2082 output = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output);
2084 // Write a build statement to copy the content into the bundle.
2085 this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(
2086 input, output, this->FileConfig);
2088 // Add as a dependency to the target so that it gets called.
2089 this->Generator->Configs[config].ExtraFiles.push_back(std::move(output));
2092 void cmNinjaTargetGenerator::addPoolNinjaVariable(
2093 const std::string& pool_property, cmGeneratorTarget* target,
2096 cmValue pool = target->GetProperty(pool_property);
2098 vars["pool"] = *pool;
2102 bool cmNinjaTargetGenerator::ForceResponseFile()
2104 static std::string const forceRspFile = "CMAKE_NINJA_FORCE_RESPONSE_FILE";
2105 return (this->GetMakefile()->IsDefinitionSet(forceRspFile) ||
2106 cmSystemTools::HasEnv(forceRspFile));