in Source/cmMakefileTargetGenerator.cxx [633:1312]
void cmMakefileTargetGenerator::WriteObjectRuleFiles(
cmSourceFile const& source)
{
// Identify the language of the source file.
std::string const& lang = source.GetLanguage();
if (lang.empty()) {
// don't know anything about this file so skip it
return;
}
// Use compiler to generate dependencies, if supported.
bool const compilerGenerateDeps =
this->GlobalGenerator->SupportsCompilerDependencies() &&
this->Makefile
->GetDefinition(cmStrCat("CMAKE_", lang, "_DEPENDS_USE_COMPILER"))
.IsOn();
auto const scanner = compilerGenerateDeps ? cmDependencyScannerKind::Compiler
: cmDependencyScannerKind::CMake;
// Get the full path name of the object file.
std::string const& objectName =
this->GeneratorTarget->GetObjectName(&source);
std::string const obj =
cmStrCat(this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
'/', objectName);
// Avoid generating duplicate rules.
if (this->ObjectFiles.find(obj) == this->ObjectFiles.end()) {
this->ObjectFiles.insert(obj);
} else {
std::ostringstream err;
err << "Warning: Source file \"" << source.GetFullPath()
<< "\" is listed multiple times for target \""
<< this->GeneratorTarget->GetName() << "\".";
cmSystemTools::Message(err.str(), "Warning");
return;
}
// Create the directory containing the object file. This may be a
// subdirectory under the target's directory.
{
std::string const dir = cmSystemTools::GetFilenamePath(obj);
cmSystemTools::MakeDirectory(this->LocalGenerator->ConvertToFullPath(dir));
}
// Save this in the target's list of object files.
this->Objects.push_back(obj);
this->CleanFiles.insert(obj);
std::vector<std::string> depends;
// The object file should be checked for dependency integrity.
std::string objFullPath =
cmStrCat(this->LocalGenerator->GetCurrentBinaryDirectory(), '/', obj);
std::string const srcFullPath = source.GetFullPath();
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, lang,
objFullPath, srcFullPath, scanner);
this->LocalGenerator->AppendRuleDepend(depends,
this->FlagFileNameFull.c_str());
this->LocalGenerator->AppendRuleDepends(depends,
this->FlagFileDepends[lang]);
// generate the depend scanning rule
this->WriteObjectDependRules(source, depends);
std::string const config = this->GetConfigName();
std::string const configUpper = cmSystemTools::UpperCase(config);
// Add precompile headers dependencies
std::vector<std::string> pchArchs =
this->GeneratorTarget->GetPchArchs(config, lang);
std::string filterArch;
std::unordered_map<std::string, std::string> pchSources;
for (std::string const& arch : pchArchs) {
std::string const pchSource =
this->GeneratorTarget->GetPchSource(config, lang, arch);
if (pchSource == source.GetFullPath()) {
filterArch = arch;
}
if (!pchSource.empty()) {
pchSources.insert(std::make_pair(pchSource, arch));
}
}
if (!pchSources.empty() && !source.GetProperty("SKIP_PRECOMPILE_HEADERS")) {
for (std::string const& arch : pchArchs) {
std::string const& pchHeader =
this->GeneratorTarget->GetPchHeader(config, lang, arch);
depends.push_back(pchHeader);
if (pchSources.find(source.GetFullPath()) == pchSources.end()) {
depends.push_back(
this->GeneratorTarget->GetPchFile(config, lang, arch));
}
this->LocalGenerator->AddImplicitDepends(
this->GeneratorTarget, lang, objFullPath, pchHeader, scanner);
}
}
if (lang != "ISPC") {
auto const& headers =
this->GeneratorTarget->GetGeneratedISPCHeaders(config);
if (!headers.empty()) {
depends.insert(depends.end(), headers.begin(), headers.end());
}
}
std::string relativeObj =
cmStrCat(this->LocalGenerator->GetHomeRelativeOutputPath(), obj);
// Write the build rule.
// Build the set of compiler flags.
std::string flags;
// Explicitly add the explicit language flag before any other flag
// so user flags can override it.
this->GeneratorTarget->AddExplicitLanguageFlags(flags, source);
// Add language-specific flags.
std::string const langFlags =
cmStrCat("$(", lang, "_FLAGS", filterArch, ")");
this->LocalGenerator->AppendFlags(flags, langFlags);
cmGeneratorExpressionInterpreter genexInterpreter(
this->LocalGenerator, config, this->GeneratorTarget, lang);
// Add Fortran format flags.
if (lang == "Fortran") {
this->AppendFortranFormatFlags(flags, source);
this->AppendFortranPreprocessFlags(flags, source);
}
std::string ispcHeaderRelative;
std::string ispcHeaderForShell;
if (lang == "ISPC") {
std::string ispcSource =
cmSystemTools::GetFilenameWithoutLastExtension(objectName);
ispcSource = cmSystemTools::GetFilenameWithoutLastExtension(ispcSource);
cmValue const ispcSuffixProp =
this->GeneratorTarget->GetProperty("ISPC_HEADER_SUFFIX");
assert(ispcSuffixProp);
std::string directory = this->GeneratorTarget->GetObjectDirectory(config);
if (cmValue prop =
this->GeneratorTarget->GetProperty("ISPC_HEADER_DIRECTORY")) {
directory =
cmStrCat(this->LocalGenerator->GetBinaryDirectory(), '/', *prop);
}
ispcHeaderRelative = cmStrCat(directory, '/', ispcSource, *ispcSuffixProp);
ispcHeaderForShell = this->LocalGenerator->ConvertToOutputFormat(
ispcHeaderRelative, cmOutputConverter::SHELL);
}
// Add flags from source file properties.
std::string const COMPILE_FLAGS("COMPILE_FLAGS");
if (cmValue cflags = source.GetProperty(COMPILE_FLAGS)) {
std::string const& evaluatedFlags =
genexInterpreter.Evaluate(*cflags, COMPILE_FLAGS);
this->LocalGenerator->AppendFlags(flags, evaluatedFlags);
*this->FlagFileStream << "# Custom flags: " << relativeObj
<< "_FLAGS = " << evaluatedFlags << "\n"
<< "\n";
}
std::string const COMPILE_OPTIONS("COMPILE_OPTIONS");
if (cmValue coptions = source.GetProperty(COMPILE_OPTIONS)) {
std::string const& evaluatedOptions =
genexInterpreter.Evaluate(*coptions, COMPILE_OPTIONS);
this->LocalGenerator->AppendCompileOptions(flags, evaluatedOptions);
*this->FlagFileStream << "# Custom options: " << relativeObj
<< "_OPTIONS = " << evaluatedOptions << "\n"
<< "\n";
}
// Add precompile headers compile options.
if (!pchSources.empty() && !source.GetProperty("SKIP_PRECOMPILE_HEADERS")) {
std::string pchOptions;
auto const pchIt = pchSources.find(source.GetFullPath());
if (pchIt != pchSources.end()) {
pchOptions = this->GeneratorTarget->GetPchCreateCompileOptions(
config, lang, pchIt->second);
} else {
pchOptions =
this->GeneratorTarget->GetPchUseCompileOptions(config, lang);
}
std::string const& evaluatedFlags =
genexInterpreter.Evaluate(pchOptions, COMPILE_OPTIONS);
this->LocalGenerator->AppendCompileOptions(flags, evaluatedFlags);
*this->FlagFileStream << "# PCH options: " << relativeObj
<< "_OPTIONS = " << evaluatedFlags << "\n"
<< "\n";
}
// Add include directories from source file properties.
std::vector<std::string> includes;
std::string const INCLUDE_DIRECTORIES("INCLUDE_DIRECTORIES");
if (cmValue cincludes = source.GetProperty(INCLUDE_DIRECTORIES)) {
std::string const& evaluatedIncludes =
genexInterpreter.Evaluate(*cincludes, INCLUDE_DIRECTORIES);
this->LocalGenerator->AppendIncludeDirectories(includes, evaluatedIncludes,
source);
*this->FlagFileStream << "# Custom include directories: " << relativeObj
<< "_INCLUDE_DIRECTORIES = " << evaluatedIncludes
<< "\n"
<< "\n";
}
// Add language-specific defines.
std::set<std::string> defines;
// Add source-specific preprocessor definitions.
std::string const COMPILE_DEFINITIONS("COMPILE_DEFINITIONS");
if (cmValue compile_defs = source.GetProperty(COMPILE_DEFINITIONS)) {
std::string const& evaluatedDefs =
genexInterpreter.Evaluate(*compile_defs, COMPILE_DEFINITIONS);
this->LocalGenerator->AppendDefines(defines, evaluatedDefs);
*this->FlagFileStream << "# Custom defines: " << relativeObj
<< "_DEFINES = " << evaluatedDefs << "\n"
<< "\n";
}
std::string const defPropName =
cmStrCat("COMPILE_DEFINITIONS_", configUpper);
if (cmValue config_compile_defs = source.GetProperty(defPropName)) {
std::string const& evaluatedDefs =
genexInterpreter.Evaluate(*config_compile_defs, COMPILE_DEFINITIONS);
this->LocalGenerator->AppendDefines(defines, evaluatedDefs);
*this->FlagFileStream << "# Custom defines: " << relativeObj << "_DEFINES_"
<< configUpper << " = " << evaluatedDefs << "\n"
<< "\n";
}
// Get the output paths for source and object files.
std::string const sourceFile = this->LocalGenerator->ConvertToOutputFormat(
source.GetFullPath(), cmOutputConverter::SHELL);
// Construct the build message.
std::vector<std::string> no_depends;
std::vector<std::string> commands;
// add in a progress call if needed
this->NumberOfProgressActions++;
if (!this->NoRuleMessages) {
cmLocalUnixMakefileGenerator3::EchoProgress progress;
this->MakeEchoProgress(progress);
std::string buildEcho =
cmStrCat("Building ", lang, " object ", relativeObj);
this->LocalGenerator->AppendEcho(commands, buildEcho,
cmLocalUnixMakefileGenerator3::EchoBuild,
&progress);
}
std::string targetOutPathReal;
std::string targetOutPathPDB;
std::string targetOutPathCompilePDB;
{
std::string targetFullPathReal;
std::string targetFullPathPDB;
std::string targetFullPathCompilePDB =
this->ComputeTargetCompilePDB(this->GetConfigName());
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||
this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
targetFullPathReal = this->GeneratorTarget->GetFullPath(
this->GetConfigName(), cmStateEnums::RuntimeBinaryArtifact, true);
targetFullPathPDB = cmStrCat(
this->GeneratorTarget->GetPDBDirectory(this->GetConfigName()), '/',
this->GeneratorTarget->GetPDBName(this->GetConfigName()));
}
targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(
this->LocalGenerator->MaybeRelativeToCurBinDir(targetFullPathReal),
cmOutputConverter::SHELL);
targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
targetFullPathPDB, cmOutputConverter::SHELL);
targetOutPathCompilePDB = this->LocalGenerator->ConvertToOutputFormat(
this->LocalGenerator->MaybeRelativeToCurBinDir(targetFullPathCompilePDB),
cmOutputConverter::SHELL);
if (this->LocalGenerator->IsMinGWMake() &&
cmHasLiteralSuffix(targetOutPathCompilePDB, "\\")) {
// mingw32-make incorrectly interprets 'a\ b c' as 'a b' and 'c'
// (but 'a\ b "c"' as 'a\', 'b', and 'c'!). Workaround this by
// avoiding a trailing backslash in the argument.
targetOutPathCompilePDB.back() = '/';
}
std::string const compilePdbOutputPath =
this->GeneratorTarget->GetCompilePDBDirectory(this->GetConfigName());
cmSystemTools::MakeDirectory(compilePdbOutputPath);
}
cmRulePlaceholderExpander::RuleVariables vars;
vars.CMTargetName = this->GeneratorTarget->GetName().c_str();
vars.CMTargetType =
cmState::GetTargetTypeName(this->GeneratorTarget->GetType()).c_str();
vars.CMTargetLabels = this->GeneratorTarget->GetTargetLabelsString().c_str();
vars.Language = lang.c_str();
vars.Target = targetOutPathReal.c_str();
vars.TargetPDB = targetOutPathPDB.c_str();
vars.TargetCompilePDB = targetOutPathCompilePDB.c_str();
vars.Source = sourceFile.c_str();
std::string const shellObj =
this->LocalGenerator->ConvertToOutputFormat(obj, cmOutputConverter::SHELL);
vars.Object = shellObj.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->LocalGenerator->ConvertToOutputFormat(
this->LocalGenerator->MaybeRelativeToCurBinDir(objectDir),
cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
std::string objectFileDir = cmSystemTools::GetFilenamePath(obj);
objectFileDir = this->LocalGenerator->ConvertToOutputFormat(
this->LocalGenerator->MaybeRelativeToCurBinDir(objectFileDir),
cmOutputConverter::SHELL);
vars.ObjectFileDir = objectFileDir.c_str();
vars.Flags = flags.c_str();
vars.ISPCHeader = ispcHeaderForShell.c_str();
vars.Config = this->GetConfigName().c_str();
std::string definesString = cmStrCat("$(", lang, "_DEFINES)");
this->LocalGenerator->JoinDefines(defines, definesString, lang);
vars.Defines = definesString.c_str();
std::string includesString = this->LocalGenerator->GetIncludeFlags(
includes, this->GeneratorTarget, lang, config);
this->LocalGenerator->AppendFlags(includesString,
"$(" + lang + "_INCLUDES)");
vars.Includes = includesString.c_str();
std::string dependencyTarget;
std::string shellDependencyFile;
std::string dependencyTimestamp;
if (compilerGenerateDeps) {
dependencyTarget = this->LocalGenerator->EscapeForShell(
this->LocalGenerator->ConvertToMakefilePath(
this->LocalGenerator->MaybeRelativeToTopBinDir(relativeObj)));
vars.DependencyTarget = dependencyTarget.c_str();
auto depFile = cmStrCat(obj, ".d");
shellDependencyFile = this->LocalGenerator->ConvertToOutputFormat(
depFile, cmOutputConverter::SHELL);
vars.DependencyFile = shellDependencyFile.c_str();
this->CleanFiles.insert(depFile);
dependencyTimestamp = this->LocalGenerator->MaybeRelativeToTopBinDir(
cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.ts"));
}
// At the moment, it is assumed that C, C++, Fortran, and CUDA have both
// assembly and preprocessor capabilities. The same is true for the
// ability to export compile commands
bool const lang_has_preprocessor =
((lang == "C") || (lang == "CXX") || (lang == "OBJC") ||
(lang == "OBJCXX") || (lang == "Fortran") || (lang == "CUDA") ||
lang == "ISPC" || lang == "HIP" || lang == "ASM");
bool const lang_has_assembly = lang_has_preprocessor;
bool const lang_can_export_cmds = lang_has_preprocessor;
auto rulePlaceholderExpander =
this->LocalGenerator->CreateRulePlaceholderExpander();
// Construct the compile rules.
{
std::string cudaCompileMode;
if (lang == "CUDA") {
if (this->GeneratorTarget->GetPropertyAsBool(
"CUDA_SEPARABLE_COMPILATION")) {
std::string const& rdcFlag =
this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_RDC_FLAG");
cudaCompileMode = cmStrCat(cudaCompileMode, rdcFlag, " ");
}
static std::array<cm::string_view, 4> const compileModes{
{ "PTX"_s, "CUBIN"_s, "FATBIN"_s, "OPTIX"_s }
};
bool useNormalCompileMode = true;
for (cm::string_view mode : compileModes) {
auto propName = cmStrCat("CUDA_", mode, "_COMPILATION");
auto defName = cmStrCat("_CMAKE_CUDA_", mode, "_FLAG");
if (this->GeneratorTarget->GetPropertyAsBool(propName)) {
std::string const& flag =
this->Makefile->GetRequiredDefinition(defName);
cudaCompileMode = cmStrCat(cudaCompileMode, flag);
useNormalCompileMode = false;
break;
}
}
if (useNormalCompileMode) {
std::string const& wholeFlag =
this->Makefile->GetRequiredDefinition("_CMAKE_CUDA_WHOLE_FLAG");
cudaCompileMode = cmStrCat(cudaCompileMode, wholeFlag);
}
vars.CudaCompileMode = cudaCompileMode.c_str();
}
cmList compileCommands;
std::string const& compileRule = this->Makefile->GetRequiredDefinition(
"CMAKE_" + lang + "_COMPILE_OBJECT");
compileCommands.assign(compileRule);
if (this->GeneratorTarget->GetPropertyAsBool("EXPORT_COMPILE_COMMANDS") &&
lang_can_export_cmds && compileCommands.size() == 1) {
std::string compileCommand = compileCommands[0];
// no launcher for CMAKE_EXPORT_COMPILE_COMMANDS
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
compileCommand, vars);
std::string const workingDirectory =
this->LocalGenerator->GetCurrentBinaryDirectory();
std::string::size_type lfPos = compileCommand.find(langFlags);
if (lfPos != std::string::npos) {
compileCommand.replace(lfPos, langFlags.size(),
this->GetFlags(lang, this->GetConfigName()));
}
std::string const langDefines = std::string("$(") + lang + "_DEFINES)";
std::string::size_type const ldPos = compileCommand.find(langDefines);
if (ldPos != std::string::npos) {
compileCommand.replace(ldPos, langDefines.size(),
this->GetDefines(lang, this->GetConfigName()));
}
std::string const langIncludes = std::string("$(") + lang + "_INCLUDES)";
std::string::size_type const liPos = compileCommand.find(langIncludes);
if (liPos != std::string::npos) {
compileCommand.replace(liPos, langIncludes.size(),
this->GetIncludes(lang, this->GetConfigName()));
}
cmValue const eliminate[] = {
this->Makefile->GetDefinition("CMAKE_START_TEMP_FILE"),
this->Makefile->GetDefinition("CMAKE_END_TEMP_FILE")
};
for (cmValue const& el : eliminate) {
if (el) {
cmSystemTools::ReplaceString(compileCommand, *el, "");
}
}
this->GlobalGenerator->AddCXXCompileCommand(
source.GetFullPath(), workingDirectory, compileCommand, relativeObj);
}
// See if we need to use a compiler launcher like ccache or distcc
std::string compilerLauncher;
if (!compileCommands.empty()) {
compilerLauncher = GetCompilerLauncher(lang, config);
}
cmValue const skipCodeCheck = source.GetProperty("SKIP_LINTING");
if (!skipCodeCheck.IsOn()) {
std::string const codeCheck = this->GenerateCodeCheckRules(
source, compilerLauncher, "$(CMAKE_COMMAND)", config, nullptr);
if (!codeCheck.empty()) {
compileCommands.front().insert(0, codeCheck);
}
}
// If compiler launcher was specified and not consumed above, it
// goes to the beginning of the command line.
if (!compileCommands.empty() && !compilerLauncher.empty()) {
cmList args{ compilerLauncher, cmList::EmptyElements::Yes };
if (!args.empty()) {
args[0] = this->LocalGenerator->ConvertToOutputFormat(
args[0], cmOutputConverter::SHELL);
for (std::string& i : cmMakeRange(args.begin() + 1, args.end())) {
i = this->LocalGenerator->EscapeForShell(i);
}
}
compileCommands.front().insert(0, args.join(" ") + " ");
}
std::string launcher;
{
std::string val = this->LocalGenerator->GetRuleLauncher(
this->GeneratorTarget, "RULE_LAUNCH_COMPILE",
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
if (cmNonempty(val)) {
launcher = cmStrCat(val, ' ');
}
}
std::string flagsWithDeps(flags);
if (compilerGenerateDeps) {
// Injects dependency computation
auto depFlags = this->Makefile->GetSafeDefinition(
cmStrCat("CMAKE_DEPFILE_FLAGS_", lang));
if (!depFlags.empty()) {
// Add dependency flags
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
depFlags, vars);
flagsWithDeps.append(1, ' ');
flagsWithDeps.append(depFlags);
}
vars.Flags = flagsWithDeps.c_str();
auto const& extraCommands = this->Makefile->GetSafeDefinition(
cmStrCat("CMAKE_", lang, "_DEPENDS_EXTRA_COMMANDS"));
if (!extraCommands.empty()) {
compileCommands.append(extraCommands);
}
auto const& depFormat = this->Makefile->GetRequiredDefinition(
cmStrCat("CMAKE_", lang, "_DEPFILE_FORMAT"));
if (depFormat == "msvc"_s) {
// compiler must be launched through a wrapper to pick-up dependencies
std::string depFilter =
"$(CMAKE_COMMAND) -E cmake_cl_compile_depends ";
depFilter += cmStrCat("--dep-file=", shellDependencyFile);
depFilter +=
cmStrCat(" --working-dir=",
this->LocalGenerator->ConvertToOutputFormat(
this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::SHELL));
auto const& prefix = this->Makefile->GetSafeDefinition(
cmStrCat("CMAKE_", lang, "_CL_SHOWINCLUDES_PREFIX"));
depFilter += cmStrCat(" --filter-prefix=",
this->LocalGenerator->ConvertToOutputFormat(
prefix, cmOutputConverter::SHELL));
depFilter += " -- ";
compileCommands.front().insert(0, depFilter);
}
}
// Expand placeholders in the commands.
for (std::string& compileCommand : compileCommands) {
compileCommand = cmStrCat(launcher, compileCommand);
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
compileCommand, vars);
}
// Change the command working directory to the local build tree.
this->LocalGenerator->CreateCDCommand(
compileCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
this->LocalGenerator->GetBinaryDirectory());
cm::append(commands, compileCommands);
}
// Check for extra outputs created by the compilation.
cmList outputs;
outputs.emplace_back(relativeObj);
if (cmValue extra_outputs_str = source.GetProperty("OBJECT_OUTPUTS")) {
std::string evaluated_outputs = cmGeneratorExpression::Evaluate(
*extra_outputs_str, this->LocalGenerator, config);
if (!evaluated_outputs.empty()) {
// Register these as extra files to clean.
outputs.append(evaluated_outputs);
}
}
if (!ispcHeaderRelative.empty()) {
// can't move ispcHeader as vars is using it
outputs.emplace_back(ispcHeaderRelative);
}
if (outputs.size() > 1) {
this->CleanFiles.insert(outputs.begin() + 1, outputs.end());
}
if (compilerGenerateDeps) {
depends.push_back(dependencyTimestamp);
}
// Write the rule.
this->WriteMakeRule(*this->BuildFileStream, nullptr, outputs, depends,
commands);
if (compilerGenerateDeps) {
// set back flags without dependency generation
vars.Flags = flags.c_str();
}
bool do_preprocess_rules = lang_has_preprocessor &&
this->LocalGenerator->GetCreatePreprocessedSourceRules();
bool do_assembly_rules =
lang_has_assembly && this->LocalGenerator->GetCreateAssemblySourceRules();
if (do_preprocess_rules || do_assembly_rules) {
std::vector<std::string> force_depends;
force_depends.emplace_back("cmake_force");
std::string::size_type dot_pos = relativeObj.rfind('.');
std::string relativeObjBase = relativeObj.substr(0, dot_pos);
dot_pos = obj.rfind('.');
std::string objBase = obj.substr(0, dot_pos);
if (do_preprocess_rules) {
commands.clear();
std::string const relativeObjI = relativeObjBase + ".i";
std::string const objI = objBase + ".i";
std::string preprocessEcho =
cmStrCat("Preprocessing ", lang, " source to ", objI);
this->LocalGenerator->AppendEcho(
commands, preprocessEcho, cmLocalUnixMakefileGenerator3::EchoBuild);
std::string preprocessRuleVar =
cmStrCat("CMAKE_", lang, "_CREATE_PREPROCESSED_SOURCE");
if (cmValue preprocessRule =
this->Makefile->GetDefinition(preprocessRuleVar)) {
cmList preprocessCommands{ *preprocessRule };
std::string shellObjI = this->LocalGenerator->ConvertToOutputFormat(
objI, cmOutputConverter::SHELL);
vars.PreprocessedSource = shellObjI.c_str();
// Expand placeholders in the commands.
for (std::string& preprocessCommand : preprocessCommands) {
// no launcher for preprocessor commands
rulePlaceholderExpander->ExpandRuleVariables(
this->LocalGenerator, preprocessCommand, vars);
}
this->LocalGenerator->CreateCDCommand(
preprocessCommands,
this->LocalGenerator->GetCurrentBinaryDirectory(),
this->LocalGenerator->GetBinaryDirectory());
cm::append(commands, preprocessCommands);
} else {
std::string cmd =
cmStrCat("$(CMAKE_COMMAND) -E cmake_unimplemented_variable ",
preprocessRuleVar);
commands.push_back(std::move(cmd));
}
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, nullptr,
relativeObjI, force_depends,
commands, false);
}
if (do_assembly_rules) {
commands.clear();
std::string relativeObjS = relativeObjBase + ".s";
std::string objS = objBase + ".s";
std::string assemblyEcho =
cmStrCat("Compiling ", lang, " source to assembly ", objS);
this->LocalGenerator->AppendEcho(
commands, assemblyEcho, cmLocalUnixMakefileGenerator3::EchoBuild);
std::string assemblyRuleVar =
cmStrCat("CMAKE_", lang, "_CREATE_ASSEMBLY_SOURCE");
if (cmValue assemblyRule =
this->Makefile->GetDefinition(assemblyRuleVar)) {
cmList assemblyCommands{ *assemblyRule };
std::string shellObjS = this->LocalGenerator->ConvertToOutputFormat(
objS, cmOutputConverter::SHELL);
vars.AssemblySource = shellObjS.c_str();
// Expand placeholders in the commands.
for (std::string& assemblyCommand : assemblyCommands) {
// no launcher for assembly commands
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
assemblyCommand, vars);
}
this->LocalGenerator->CreateCDCommand(
assemblyCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
this->LocalGenerator->GetBinaryDirectory());
cm::append(commands, assemblyCommands);
} else {
std::string cmd =
cmStrCat("$(CMAKE_COMMAND) -E cmake_unimplemented_variable ",
assemblyRuleVar);
commands.push_back(std::move(cmd));
}
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, nullptr,
relativeObjS, force_depends,
commands, false);
}
}
}