/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmCoreTryCompile.h" #include #include #include #include #include #include #include #include #include "cmsys/Directory.hxx" #include "cmArgumentParser.h" #include "cmExportTryCompileFileGenerator.h" #include "cmGlobalGenerator.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmOutputConverter.h" #include "cmPolicies.h" #include "cmRange.h" #include "cmState.h" #include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmValue.h" #include "cmVersion.h" #include "cmake.h" namespace { constexpr size_t lang_property_start = 0; constexpr size_t lang_property_size = 4; constexpr size_t pie_property_start = 4; constexpr size_t pie_property_size = 2; #define SETUP_LANGUAGE(name, lang) \ static const std::string name[lang_property_size + pie_property_size + 1] = \ { "CMAKE_" #lang "_COMPILER_EXTERNAL_TOOLCHAIN", \ "CMAKE_" #lang "_COMPILER_TARGET", \ "CMAKE_" #lang "_LINK_NO_PIE_SUPPORTED", \ "CMAKE_" #lang "_PIE_SUPPORTED", "" } // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(c_properties, C); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(cxx_properties, CXX); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(cuda_properties, CUDA); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(fortran_properties, Fortran); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(hip_properties, HIP); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(objc_properties, OBJC); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(objcxx_properties, OBJCXX); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(ispc_properties, ISPC); // NOLINTNEXTLINE(bugprone-suspicious-missing-comma) SETUP_LANGUAGE(swift_properties, Swift); #undef SETUP_LANGUAGE std::string const kCMAKE_CUDA_ARCHITECTURES = "CMAKE_CUDA_ARCHITECTURES"; std::string const kCMAKE_CUDA_RUNTIME_LIBRARY = "CMAKE_CUDA_RUNTIME_LIBRARY"; std::string const kCMAKE_ENABLE_EXPORTS = "CMAKE_ENABLE_EXPORTS"; std::string const kCMAKE_HIP_ARCHITECTURES = "CMAKE_HIP_ARCHITECTURES"; std::string const kCMAKE_HIP_RUNTIME_LIBRARY = "CMAKE_HIP_RUNTIME_LIBRARY"; std::string const kCMAKE_ISPC_INSTRUCTION_SETS = "CMAKE_ISPC_INSTRUCTION_SETS"; std::string const kCMAKE_ISPC_HEADER_SUFFIX = "CMAKE_ISPC_HEADER_SUFFIX"; std::string const kCMAKE_LINK_SEARCH_END_STATIC = "CMAKE_LINK_SEARCH_END_STATIC"; std::string const kCMAKE_LINK_SEARCH_START_STATIC = "CMAKE_LINK_SEARCH_START_STATIC"; std::string const kCMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT = "CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT"; std::string const kCMAKE_OSX_ARCHITECTURES = "CMAKE_OSX_ARCHITECTURES"; std::string const kCMAKE_OSX_DEPLOYMENT_TARGET = "CMAKE_OSX_DEPLOYMENT_TARGET"; std::string const kCMAKE_OSX_SYSROOT = "CMAKE_OSX_SYSROOT"; std::string const kCMAKE_APPLE_ARCH_SYSROOTS = "CMAKE_APPLE_ARCH_SYSROOTS"; std::string const kCMAKE_POSITION_INDEPENDENT_CODE = "CMAKE_POSITION_INDEPENDENT_CODE"; std::string const kCMAKE_SYSROOT = "CMAKE_SYSROOT"; std::string const kCMAKE_SYSROOT_COMPILE = "CMAKE_SYSROOT_COMPILE"; std::string const kCMAKE_SYSROOT_LINK = "CMAKE_SYSROOT_LINK"; std::string const kCMAKE_ARMClang_CMP0123 = "CMAKE_ARMClang_CMP0123"; std::string const kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES = "CMAKE_TRY_COMPILE_OSX_ARCHITECTURES"; std::string const kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES = "CMAKE_TRY_COMPILE_PLATFORM_VARIABLES"; std::string const kCMAKE_WARN_DEPRECATED = "CMAKE_WARN_DEPRECATED"; std::string const kCMAKE_WATCOM_RUNTIME_LIBRARY_DEFAULT = "CMAKE_WATCOM_RUNTIME_LIBRARY_DEFAULT"; /* GHS Multi platform variables */ std::set const ghs_platform_vars{ "GHS_TARGET_PLATFORM", "GHS_PRIMARY_TARGET", "GHS_TOOLSET_ROOT", "GHS_OS_ROOT", "GHS_OS_DIR", "GHS_BSP_NAME", "GHS_OS_DIR_OPTION" }; using Arguments = cmCoreTryCompile::Arguments; ArgumentParser::Continue TryCompileLangProp(Arguments& args, cm::string_view key, cm::string_view val) { args.LangProps[std::string(key)] = std::string(val); return ArgumentParser::Continue::No; } ArgumentParser::Continue TryCompileCompileDefs(Arguments& args, cm::string_view val) { cmExpandList(val, args.CompileDefs); return ArgumentParser::Continue::Yes; } #define BIND_LANG_PROPS(lang) \ Bind(#lang "_STANDARD"_s, TryCompileLangProp) \ .Bind(#lang "_STANDARD_REQUIRED"_s, TryCompileLangProp) \ .Bind(#lang "_EXTENSIONS"_s, TryCompileLangProp) auto const TryCompileArgParser = cmArgumentParser{} .Bind(0, &Arguments::CompileResultVariable) .Bind(1, &Arguments::BinaryDirectory) .Bind(2, &Arguments::SourceDirectoryOrFile) .Bind(3, &Arguments::ProjectName) .Bind(4, &Arguments::TargetName) .Bind("SOURCES"_s, &Arguments::Sources) .Bind("CMAKE_FLAGS"_s, &Arguments::CMakeFlags) .Bind("COMPILE_DEFINITIONS"_s, TryCompileCompileDefs, ArgumentParser::ExpectAtLeast{ 0 }) .Bind("LINK_LIBRARIES"_s, &Arguments::LinkLibraries) .Bind("LINK_OPTIONS"_s, &Arguments::LinkOptions) .Bind("__CMAKE_INTERNAL"_s, &Arguments::CMakeInternal) .Bind("OUTPUT_VARIABLE"_s, &Arguments::OutputVariable) .Bind("COPY_FILE"_s, &Arguments::CopyFileTo) .Bind("COPY_FILE_ERROR"_s, &Arguments::CopyFileError) .BIND_LANG_PROPS(C) .BIND_LANG_PROPS(CUDA) .BIND_LANG_PROPS(CXX) .BIND_LANG_PROPS(HIP) .BIND_LANG_PROPS(OBJC) .BIND_LANG_PROPS(OBJCXX) .Bind("COMPILE_OUTPUT_VARIABLE"_s, &Arguments::CompileOutputVariable) .Bind("RUN_OUTPUT_VARIABLE"_s, &Arguments::RunOutputVariable) .Bind("RUN_OUTPUT_STDOUT_VARIABLE"_s, &Arguments::RunOutputStdOutVariable) .Bind("RUN_OUTPUT_STDERR_VARIABLE"_s, &Arguments::RunOutputStdErrVariable) .Bind("WORKING_DIRECTORY"_s, &Arguments::RunWorkingDirectory) .Bind("ARGS"_s, &Arguments::RunArgs) /* keep semicolon on own line */; #undef BIND_LANG_PROPS } Arguments cmCoreTryCompile::ParseArgs( cmRange::const_iterator> args, bool isTryRun) { std::vector unparsedArguments; auto arguments = TryCompileArgParser.Parse(args, &unparsedArguments, 0); if (!arguments.MaybeReportError(*(this->Makefile)) && !unparsedArguments.empty()) { std::string m = "Unknown arguments:"; for (const auto& i : unparsedArguments) { m = cmStrCat(m, "\n ", i, "\""); } this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, m); } // For historical reasons, treat some empty-valued keyword // arguments as if they were not specified at all. if (arguments.OutputVariable && arguments.OutputVariable->empty()) { arguments.OutputVariable = cm::nullopt; } if (isTryRun) { if (arguments.CompileOutputVariable && arguments.CompileOutputVariable->empty()) { arguments.CompileOutputVariable = cm::nullopt; } if (arguments.RunOutputVariable && arguments.RunOutputVariable->empty()) { arguments.RunOutputVariable = cm::nullopt; } if (arguments.RunOutputStdOutVariable && arguments.RunOutputStdOutVariable->empty()) { arguments.RunOutputStdOutVariable = cm::nullopt; } if (arguments.RunOutputStdErrVariable && arguments.RunOutputStdErrVariable->empty()) { arguments.RunOutputStdErrVariable = cm::nullopt; } if (arguments.RunWorkingDirectory && arguments.RunWorkingDirectory->empty()) { arguments.RunWorkingDirectory = cm::nullopt; } } else { std::string tryRunArgs; if (arguments.CompileOutputVariable) { tryRunArgs = cmStrCat(tryRunArgs, " COMPILE_OUTPUT_VARIABLE\n"); } if (arguments.RunOutputVariable) { tryRunArgs = cmStrCat(tryRunArgs, " RUN_OUTPUT_VARIABLE\n"); } if (arguments.RunOutputStdOutVariable) { tryRunArgs = cmStrCat(tryRunArgs, " RUN_OUTPUT_STDOUT_VARIABLE\n"); } if (arguments.RunOutputStdErrVariable) { tryRunArgs = cmStrCat(tryRunArgs, " RUN_OUTPUT_STDERR_VARIABLE\n"); } if (arguments.RunWorkingDirectory) { tryRunArgs = cmStrCat(tryRunArgs, " WORKING_DIRECTORY\n"); } if (arguments.RunArgs) { tryRunArgs = cmStrCat(tryRunArgs, " ARGS\n"); } if (!tryRunArgs.empty()) { this->Makefile->IssueMessage( MessageType::AUTHOR_WARNING, cmStrCat("Ignoring try_run arguments for try_compile:\n", tryRunArgs)); } } return arguments; } bool cmCoreTryCompile::TryCompileCode(Arguments& arguments, cmStateEnums::TargetType targetType) { this->OutputFile.clear(); // which signature were we called with ? this->SrcFileSignature = true; std::string sourceDirectory; std::string projectName; std::string targetName; if (arguments.SourceDirectoryOrFile && arguments.ProjectName) { this->SrcFileSignature = false; sourceDirectory = *arguments.SourceDirectoryOrFile; projectName = *arguments.ProjectName; if (arguments.TargetName) { targetName = *arguments.TargetName; } } else { projectName = "CMAKE_TRY_COMPILE"; /* Use a random file name to avoid rapid creation and deletion of the same executable name (some filesystems fail on that). */ char targetNameBuf[64]; snprintf(targetNameBuf, sizeof(targetNameBuf), "cmTC_%05x", cmSystemTools::RandomSeed() & 0xFFFFF); targetName = targetNameBuf; } if (arguments.BinaryDirectory && !arguments.BinaryDirectory->empty()) { if (!cmSystemTools::FileIsFullPath(*arguments.BinaryDirectory)) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmStrCat(" is not an absolute path:\n '", *arguments.BinaryDirectory, "'")); return false; } this->BinaryDirectory = *arguments.BinaryDirectory; // compute the binary dir when TRY_COMPILE is called with a src file // signature if (this->SrcFileSignature) { this->BinaryDirectory += "/CMakeFiles/CMakeTmp"; } } else { this->Makefile->IssueMessage(MessageType::FATAL_ERROR, "No specified."); return false; } std::vector targets; if (arguments.LinkLibraries) { for (std::string const& i : *arguments.LinkLibraries) { if (cmTarget* tgt = this->Makefile->FindTargetToUse(i)) { switch (tgt->GetType()) { case cmStateEnums::SHARED_LIBRARY: case cmStateEnums::STATIC_LIBRARY: case cmStateEnums::INTERFACE_LIBRARY: case cmStateEnums::UNKNOWN_LIBRARY: break; case cmStateEnums::EXECUTABLE: if (tgt->IsExecutableWithExports()) { break; } CM_FALLTHROUGH; default: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmStrCat("Only libraries may be used as try_compile or try_run " "IMPORTED LINK_LIBRARIES. Got ", tgt->GetName(), " of type ", cmState::GetTargetTypeName(tgt->GetType()), ".")); return false; } if (tgt->IsImported()) { targets.emplace_back(i); } } } } if (arguments.CopyFileTo && arguments.CopyFileTo->empty()) { this->Makefile->IssueMessage(MessageType::FATAL_ERROR, "COPY_FILE must be followed by a file path"); return false; } if (arguments.CopyFileError && arguments.CopyFileError->empty()) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, "COPY_FILE_ERROR must be followed by a variable name"); return false; } if (arguments.CopyFileError && !arguments.CopyFileTo) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, "COPY_FILE_ERROR may be used only with COPY_FILE"); return false; } if (arguments.Sources && arguments.Sources->empty()) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, "SOURCES must be followed by at least one source file"); return false; } // only valid for srcfile signatures if (!this->SrcFileSignature) { if (!arguments.LangProps.empty()) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmStrCat(arguments.LangProps.begin()->first, " allowed only in source file signature.")); return false; } if (!arguments.CompileDefs.empty()) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, "COMPILE_DEFINITIONS specified on a srcdir type TRY_COMPILE"); return false; } if (arguments.CopyFileTo) { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, "COPY_FILE specified on a srcdir type TRY_COMPILE"); return false; } } // make sure the binary directory exists cmSystemTools::MakeDirectory(this->BinaryDirectory); // do not allow recursive try Compiles if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory()) { std::ostringstream e; e << "Attempt at a recursive or nested TRY_COMPILE in directory\n" << " " << this->BinaryDirectory << "\n"; this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str()); return false; } std::string outFileName = this->BinaryDirectory + "/CMakeLists.txt"; // which signature are we using? If we are using var srcfile bindir if (this->SrcFileSignature) { // remove any CMakeCache.txt files so we will have a clean test std::string ccFile = this->BinaryDirectory + "/CMakeCache.txt"; cmSystemTools::RemoveFile(ccFile); // Choose sources. std::vector sources; if (arguments.Sources) { sources = std::move(*arguments.Sources); } else { // TODO: ensure SourceDirectoryOrFile has a value sources.emplace_back(*arguments.SourceDirectoryOrFile); } // Detect languages to enable. cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); std::set testLangs; for (std::string const& si : sources) { std::string ext = cmSystemTools::GetFilenameLastExtension(si); std::string lang = gg->GetLanguageFromExtension(ext.c_str()); if (!lang.empty()) { testLangs.insert(lang); } else { std::ostringstream err; err << "Unknown extension \"" << ext << "\" for file\n" << " " << si << "\n" << "try_compile() works only for enabled languages. " << "Currently these are:\n "; std::vector langs; gg->GetEnabledLanguages(langs); err << cmJoin(langs, " "); err << "\nSee project() command to enable other languages."; this->Makefile->IssueMessage(MessageType::FATAL_ERROR, err.str()); return false; } } // when the only language is ISPC we know that the output // type must by a static library if (testLangs.size() == 1 && testLangs.count("ISPC") == 1) { targetType = cmStateEnums::STATIC_LIBRARY; } std::string const tcConfig = this->Makefile->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION"); // we need to create a directory and CMakeLists file etc... // first create the directories sourceDirectory = this->BinaryDirectory; // now create a CMakeLists.txt file in that directory FILE* fout = cmsys::SystemTools::Fopen(outFileName, "w"); if (!fout) { std::ostringstream e; /* clang-format off */ e << "Failed to open\n" << " " << outFileName << "\n" << cmSystemTools::GetLastSystemError(); /* clang-format on */ this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str()); return false; } cmValue def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH"); fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n", cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(), cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion()); if (def) { fprintf(fout, "set(CMAKE_MODULE_PATH \"%s\")\n", def->c_str()); } /* Set MSVC runtime library policy to match our selection. */ if (cmValue msvcRuntimeLibraryDefault = this->Makefile->GetDefinition(kCMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT)) { fprintf(fout, "cmake_policy(SET CMP0091 %s)\n", !msvcRuntimeLibraryDefault->empty() ? "NEW" : "OLD"); } /* Set Watcom runtime library policy to match our selection. */ if (cmValue watcomRuntimeLibraryDefault = this->Makefile->GetDefinition( kCMAKE_WATCOM_RUNTIME_LIBRARY_DEFAULT)) { fprintf(fout, "cmake_policy(SET CMP0136 %s)\n", !watcomRuntimeLibraryDefault->empty() ? "NEW" : "OLD"); } /* Set CUDA architectures policy to match outer project. */ if (this->Makefile->GetPolicyStatus(cmPolicies::CMP0104) != cmPolicies::NEW && testLangs.find("CUDA") != testLangs.end() && this->Makefile->GetSafeDefinition(kCMAKE_CUDA_ARCHITECTURES).empty()) { fprintf(fout, "cmake_policy(SET CMP0104 OLD)\n"); } /* Set ARMClang cpu/arch policy to match outer project. */ if (cmValue cmp0123 = this->Makefile->GetDefinition(kCMAKE_ARMClang_CMP0123)) { fprintf(fout, "cmake_policy(SET CMP0123 %s)\n", *cmp0123 == "NEW"_s ? "NEW" : "OLD"); } /* Set cache/normal variable policy to match outer project. It may affect toolchain files. */ if (this->Makefile->GetPolicyStatus(cmPolicies::CMP0126) != cmPolicies::NEW) { fprintf(fout, "cmake_policy(SET CMP0126 OLD)\n"); } std::string projectLangs; for (std::string const& li : testLangs) { projectLangs += " " + li; std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE"; std::string rulesOverrideLang = cmStrCat(rulesOverrideBase, "_", li); if (cmValue rulesOverridePath = this->Makefile->GetDefinition(rulesOverrideLang)) { fprintf(fout, "set(%s \"%s\")\n", rulesOverrideLang.c_str(), rulesOverridePath->c_str()); } else if (cmValue rulesOverridePath2 = this->Makefile->GetDefinition(rulesOverrideBase)) { fprintf(fout, "set(%s \"%s\")\n", rulesOverrideBase.c_str(), rulesOverridePath2->c_str()); } } fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str()); if (arguments.CMakeInternal == "ABI") { // This is the ABI detection step, also used for implicit includes. // Erase any include_directories() calls from the toolchain file so // that we do not see them as implicit. Our ABI detection source // does not include any system headers anyway. fprintf(fout, "set_property(DIRECTORY PROPERTY INCLUDE_DIRECTORIES \"\")\n"); // The link and compile lines for ABI detection step need to not use // response files so we can extract implicit includes given to // the underlying host compiler if (testLangs.find("CUDA") != testLangs.end()) { fprintf(fout, "set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_INCLUDES OFF)\n"); fprintf(fout, "set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_LIBRARIES OFF)\n"); fprintf(fout, "set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_OBJECTS OFF)\n"); } } fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n"); for (std::string const& li : testLangs) { std::string langFlags = "CMAKE_" + li + "_FLAGS"; cmValue flags = this->Makefile->GetDefinition(langFlags); fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li.c_str(), cmOutputConverter::EscapeForCMake(*flags).c_str()); fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}" " ${COMPILE_DEFINITIONS}\")\n", li.c_str(), li.c_str()); } switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0066)) { case cmPolicies::WARN: if (this->Makefile->PolicyOptionalWarningEnabled( "CMAKE_POLICY_WARNING_CMP0066")) { std::ostringstream w; /* clang-format off */ w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0066) << "\n" "For compatibility with older versions of CMake, try_compile " "is not honoring caller config-specific compiler flags " "(e.g. CMAKE_C_FLAGS_DEBUG) in the test project." ; /* clang-format on */ this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, w.str()); } CM_FALLTHROUGH; case cmPolicies::OLD: // OLD behavior is to do nothing. break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0066)); CM_FALLTHROUGH; case cmPolicies::NEW: { // NEW behavior is to pass config-specific compiler flags. static std::string const cfgDefault = "DEBUG"; std::string const cfg = !tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault; for (std::string const& li : testLangs) { std::string const langFlagsCfg = cmStrCat("CMAKE_", li, "_FLAGS_", cfg); cmValue flagsCfg = this->Makefile->GetDefinition(langFlagsCfg); fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(), cmOutputConverter::EscapeForCMake(*flagsCfg).c_str()); } } break; } switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0056)) { case cmPolicies::WARN: if (this->Makefile->PolicyOptionalWarningEnabled( "CMAKE_POLICY_WARNING_CMP0056")) { std::ostringstream w; /* clang-format off */ w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0056) << "\n" "For compatibility with older versions of CMake, try_compile " "is not honoring caller link flags (e.g. CMAKE_EXE_LINKER_FLAGS) " "in the test project." ; /* clang-format on */ this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, w.str()); } CM_FALLTHROUGH; case cmPolicies::OLD: // OLD behavior is to do nothing. break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056)); CM_FALLTHROUGH; case cmPolicies::NEW: // NEW behavior is to pass linker flags. { cmValue exeLinkFlags = this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS"); fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n", cmOutputConverter::EscapeForCMake(*exeLinkFlags).c_str()); } break; } fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS}" " ${EXE_LINKER_FLAGS}\")\n"); fprintf(fout, "include_directories(${INCLUDE_DIRECTORIES})\n"); fprintf(fout, "set(CMAKE_SUPPRESS_REGENERATION 1)\n"); fprintf(fout, "link_directories(${LINK_DIRECTORIES})\n"); // handle any compile flags we need to pass on if (!arguments.CompileDefs.empty()) { // Pass using bracket arguments to preserve content. fprintf(fout, "add_definitions([==[%s]==])\n", cmJoin(arguments.CompileDefs, "]==] [==[").c_str()); } if (!targets.empty()) { std::string fname = "/" + std::string(targetName) + "Targets.cmake"; cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile, testLangs); tcfg.SetExportFile((this->BinaryDirectory + fname).c_str()); tcfg.SetConfig(tcConfig); if (!tcfg.GenerateImportFile()) { this->Makefile->IssueMessage(MessageType::FATAL_ERROR, "could not write export file."); fclose(fout); return false; } fprintf(fout, "\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/%s\")\n\n", fname.c_str()); } /* Set the appropriate policy information for ENABLE_EXPORTS */ fprintf(fout, "cmake_policy(SET CMP0065 %s)\n", this->Makefile->GetPolicyStatus(cmPolicies::CMP0065) == cmPolicies::NEW ? "NEW" : "OLD"); /* Set the appropriate policy information for PIE link flags */ fprintf(fout, "cmake_policy(SET CMP0083 %s)\n", this->Makefile->GetPolicyStatus(cmPolicies::CMP0083) == cmPolicies::NEW ? "NEW" : "OLD"); // Workaround for -Wl,-headerpad_max_install_names issue until we can avoid // adding that flag in the platform and compiler language files fprintf(fout, "include(\"${CMAKE_ROOT}/Modules/Internal/" "HeaderpadWorkaround.cmake\")\n"); if (targetType == cmStateEnums::EXECUTABLE) { /* Put the executable at a known location (for COPY_FILE). */ fprintf(fout, "set(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"%s\")\n", this->BinaryDirectory.c_str()); /* Create the actual executable. */ fprintf(fout, "add_executable(%s", targetName.c_str()); } else // if (targetType == cmStateEnums::STATIC_LIBRARY) { /* Put the static library at a known location (for COPY_FILE). */ fprintf(fout, "set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY \"%s\")\n", this->BinaryDirectory.c_str()); /* Create the actual static library. */ fprintf(fout, "add_library(%s STATIC", targetName.c_str()); } for (std::string const& si : sources) { fprintf(fout, " \"%s\"", si.c_str()); // Add dependencies on any non-temporary sources. if (si.find("CMakeTmp") == std::string::npos) { this->Makefile->AddCMakeDependFile(si); } } fprintf(fout, ")\n"); bool warnCMP0067 = false; bool honorStandard = true; if (arguments.LangProps.empty()) { switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0067)) { case cmPolicies::WARN: warnCMP0067 = this->Makefile->PolicyOptionalWarningEnabled( "CMAKE_POLICY_WARNING_CMP0067"); CM_FALLTHROUGH; case cmPolicies::OLD: // OLD behavior is to not honor the language standard variables. honorStandard = false; break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0067)); break; case cmPolicies::NEW: // NEW behavior is to honor the language standard variables. // We already initialized honorStandard to true. break; } } std::vector warnCMP0067Variables; if (honorStandard || warnCMP0067) { static std::array const possibleLangs{ { "C", "CXX", "CUDA", "HIP", "OBJC", "OBJCXX" } }; static std::array const langPropSuffixes{ { "_STANDARD"_s, "_STANDARD_REQUIRED"_s, "_EXTENSIONS"_s } }; for (std::string const& lang : possibleLangs) { if (testLangs.find(lang) == testLangs.end()) { continue; } for (cm::string_view propSuffix : langPropSuffixes) { std::string langProp = cmStrCat(lang, propSuffix); if (!arguments.LangProps.count(langProp)) { std::string langPropVar = cmStrCat("CMAKE_"_s, langProp); std::string value = this->Makefile->GetSafeDefinition(langPropVar); if (warnCMP0067 && !value.empty()) { value.clear(); warnCMP0067Variables.emplace_back(langPropVar); } if (!value.empty()) { arguments.LangProps[langProp] = value; } } } } } if (!warnCMP0067Variables.empty()) { std::ostringstream w; /* clang-format off */ w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0067) << "\n" "For compatibility with older versions of CMake, try_compile " "is not honoring language standard variables in the test project:\n" ; /* clang-format on */ for (std::string const& vi : warnCMP0067Variables) { w << " " << vi << "\n"; } this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, w.str()); } for (auto const& p : arguments.LangProps) { if (p.second.empty()) { continue; } fprintf(fout, "set_property(TARGET %s PROPERTY %s %s)\n", targetName.c_str(), cmOutputConverter::EscapeForCMake(p.first).c_str(), cmOutputConverter::EscapeForCMake(p.second).c_str()); } if (!arguments.LinkOptions.empty()) { std::vector options; options.reserve(arguments.LinkOptions.size()); for (const auto& option : arguments.LinkOptions) { options.emplace_back(cmOutputConverter::EscapeForCMake(option)); } if (targetType == cmStateEnums::STATIC_LIBRARY) { fprintf(fout, "set_property(TARGET %s PROPERTY STATIC_LIBRARY_OPTIONS %s)\n", targetName.c_str(), cmJoin(options, " ").c_str()); } else { fprintf(fout, "target_link_options(%s PRIVATE %s)\n", targetName.c_str(), cmJoin(options, " ").c_str()); } } if (arguments.LinkLibraries) { std::string libsToLink = " "; for (std::string const& i : *arguments.LinkLibraries) { libsToLink += "\"" + cmTrimWhitespace(i) + "\" "; } fprintf(fout, "target_link_libraries(%s %s)\n", targetName.c_str(), libsToLink.c_str()); } else { fprintf(fout, "target_link_libraries(%s ${LINK_LIBRARIES})\n", targetName.c_str()); } fclose(fout); } // Forward a set of variables to the inner project cache. if ((this->SrcFileSignature || this->Makefile->GetPolicyStatus(cmPolicies::CMP0137) == cmPolicies::NEW) && !this->Makefile->IsOn("CMAKE_TRY_COMPILE_NO_PLATFORM_VARIABLES")) { std::set vars; vars.insert(&c_properties[lang_property_start], &c_properties[lang_property_start + lang_property_size]); vars.insert(&cxx_properties[lang_property_start], &cxx_properties[lang_property_start + lang_property_size]); vars.insert(&cuda_properties[lang_property_start], &cuda_properties[lang_property_start + lang_property_size]); vars.insert(&fortran_properties[lang_property_start], &fortran_properties[lang_property_start + lang_property_size]); vars.insert(&hip_properties[lang_property_start], &hip_properties[lang_property_start + lang_property_size]); vars.insert(&objc_properties[lang_property_start], &objc_properties[lang_property_start + lang_property_size]); vars.insert(&objcxx_properties[lang_property_start], &objcxx_properties[lang_property_start + lang_property_size]); vars.insert(&ispc_properties[lang_property_start], &ispc_properties[lang_property_start + lang_property_size]); vars.insert(&swift_properties[lang_property_start], &swift_properties[lang_property_start + lang_property_size]); vars.insert(kCMAKE_CUDA_ARCHITECTURES); vars.insert(kCMAKE_CUDA_RUNTIME_LIBRARY); vars.insert(kCMAKE_ENABLE_EXPORTS); vars.insert(kCMAKE_HIP_ARCHITECTURES); vars.insert(kCMAKE_HIP_RUNTIME_LIBRARY); vars.insert(kCMAKE_ISPC_INSTRUCTION_SETS); vars.insert(kCMAKE_ISPC_HEADER_SUFFIX); vars.insert(kCMAKE_LINK_SEARCH_END_STATIC); vars.insert(kCMAKE_LINK_SEARCH_START_STATIC); vars.insert(kCMAKE_OSX_ARCHITECTURES); vars.insert(kCMAKE_OSX_DEPLOYMENT_TARGET); vars.insert(kCMAKE_OSX_SYSROOT); vars.insert(kCMAKE_APPLE_ARCH_SYSROOTS); vars.insert(kCMAKE_POSITION_INDEPENDENT_CODE); vars.insert(kCMAKE_SYSROOT); vars.insert(kCMAKE_SYSROOT_COMPILE); vars.insert(kCMAKE_SYSROOT_LINK); vars.insert(kCMAKE_WARN_DEPRECATED); vars.emplace("CMAKE_MSVC_RUNTIME_LIBRARY"_s); vars.emplace("CMAKE_WATCOM_RUNTIME_LIBRARY"_s); if (cmValue varListStr = this->Makefile->GetDefinition( kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES)) { std::vector varList = cmExpandedList(*varListStr); vars.insert(varList.begin(), varList.end()); } if (this->Makefile->GetPolicyStatus(cmPolicies::CMP0083) == cmPolicies::NEW) { // To ensure full support of PIE, propagate cache variables // driving the link options vars.insert(&c_properties[pie_property_start], &c_properties[pie_property_start + pie_property_size]); vars.insert(&cxx_properties[pie_property_start], &cxx_properties[pie_property_start + pie_property_size]); vars.insert(&cuda_properties[pie_property_start], &cuda_properties[pie_property_start + pie_property_size]); vars.insert(&fortran_properties[pie_property_start], &fortran_properties[pie_property_start + pie_property_size]); vars.insert(&hip_properties[pie_property_start], &hip_properties[pie_property_start + pie_property_size]); vars.insert(&objc_properties[pie_property_start], &objc_properties[pie_property_start + pie_property_size]); vars.insert(&objcxx_properties[pie_property_start], &objcxx_properties[pie_property_start + pie_property_size]); vars.insert(&ispc_properties[pie_property_start], &ispc_properties[pie_property_start + pie_property_size]); vars.insert(&swift_properties[pie_property_start], &swift_properties[pie_property_start + pie_property_size]); } /* for the TRY_COMPILEs we want to be able to specify the architecture. So the user can set CMAKE_OSX_ARCHITECTURES to i386;ppc and then set CMAKE_TRY_COMPILE_OSX_ARCHITECTURES first to i386 and then to ppc to have the tests run for each specific architecture. Since cmLocalGenerator doesn't allow building for "the other" architecture only via CMAKE_OSX_ARCHITECTURES. */ if (cmValue tcArchs = this->Makefile->GetDefinition( kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES)) { vars.erase(kCMAKE_OSX_ARCHITECTURES); std::string flag = "-DCMAKE_OSX_ARCHITECTURES=" + *tcArchs; arguments.CMakeFlags.emplace_back(std::move(flag)); } for (std::string const& var : vars) { if (cmValue val = this->Makefile->GetDefinition(var)) { std::string flag = "-D" + var + "=" + *val; arguments.CMakeFlags.emplace_back(std::move(flag)); } } } if (this->Makefile->GetState()->UseGhsMultiIDE()) { // Forward the GHS variables to the inner project cache. for (std::string const& var : ghs_platform_vars) { if (cmValue val = this->Makefile->GetDefinition(var)) { std::string flag = "-D" + var + "=" + "'" + *val + "'"; arguments.CMakeFlags.emplace_back(std::move(flag)); } } } bool erroroc = cmSystemTools::GetErrorOccurredFlag(); cmSystemTools::ResetErrorOccurredFlag(); std::string output; // actually do the try compile now that everything is setup int res = this->Makefile->TryCompile( sourceDirectory, this->BinaryDirectory, projectName, targetName, this->SrcFileSignature, cmake::NO_BUILD_PARALLEL_LEVEL, &arguments.CMakeFlags, output); if (erroroc) { cmSystemTools::SetErrorOccurred(); } // set the result var to the return value to indicate success or failure this->Makefile->AddCacheDefinition( *arguments.CompileResultVariable, (res == 0 ? "TRUE" : "FALSE"), "Result of TRY_COMPILE", cmStateEnums::INTERNAL); if (arguments.OutputVariable) { this->Makefile->AddDefinition(*arguments.OutputVariable, output); } if (this->SrcFileSignature) { std::string copyFileErrorMessage; this->FindOutputFile(targetName, targetType); if ((res == 0) && arguments.CopyFileTo) { std::string const& copyFile = *arguments.CopyFileTo; if (this->OutputFile.empty() || !cmSystemTools::CopyFileAlways(this->OutputFile, copyFile)) { std::ostringstream emsg; /* clang-format off */ emsg << "Cannot copy output executable\n" << " '" << this->OutputFile << "'\n" << "to destination specified by COPY_FILE:\n" << " '" << copyFile << "'\n"; /* clang-format on */ if (!this->FindErrorMessage.empty()) { emsg << this->FindErrorMessage; } if (!arguments.CopyFileError) { this->Makefile->IssueMessage(MessageType::FATAL_ERROR, emsg.str()); return false; } copyFileErrorMessage = emsg.str(); } } if (arguments.CopyFileError) { std::string const& copyFileError = *arguments.CopyFileError; this->Makefile->AddDefinition(copyFileError, copyFileErrorMessage); } } return res == 0; } void cmCoreTryCompile::CleanupFiles(std::string const& binDir) { if (binDir.empty()) { return; } if (binDir.find("CMakeTmp") == std::string::npos) { cmSystemTools::Error( "TRY_COMPILE attempt to remove -rf directory that does not contain " "CMakeTmp:" + binDir); return; } cmsys::Directory dir; dir.Load(binDir); std::set deletedFiles; for (unsigned long i = 0; i < dir.GetNumberOfFiles(); ++i) { const char* fileName = dir.GetFile(i); if (strcmp(fileName, ".") != 0 && strcmp(fileName, "..") != 0 && // Do not delete NFS temporary files. !cmHasPrefix(fileName, ".nfs")) { if (deletedFiles.insert(fileName).second) { std::string const fullPath = std::string(binDir).append("/").append(fileName); if (cmSystemTools::FileIsSymlink(fullPath)) { cmSystemTools::RemoveFile(fullPath); } else if (cmSystemTools::FileIsDirectory(fullPath)) { this->CleanupFiles(fullPath); cmSystemTools::RemoveADirectory(fullPath); } else { #ifdef _WIN32 // Sometimes anti-virus software hangs on to new files so we // cannot delete them immediately. Try a few times. cmSystemTools::WindowsFileRetry retry = cmSystemTools::GetWindowsFileRetry(); cmsys::Status status; while (!((status = cmSystemTools::RemoveFile(fullPath))) && --retry.Count && cmSystemTools::FileExists(fullPath)) { cmSystemTools::Delay(retry.Delay); } if (retry.Count == 0) #else cmsys::Status status = cmSystemTools::RemoveFile(fullPath); if (!status) #endif { this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmStrCat("The file:\n ", fullPath, "\ncould not be removed:\n ", status.GetString())); } } } } } } void cmCoreTryCompile::FindOutputFile(const std::string& targetName, cmStateEnums::TargetType targetType) { this->FindErrorMessage.clear(); this->OutputFile.clear(); std::string tmpOutputFile = "/"; if (targetType == cmStateEnums::EXECUTABLE) { tmpOutputFile += targetName; tmpOutputFile += this->Makefile->GetSafeDefinition("CMAKE_EXECUTABLE_SUFFIX"); } else // if (targetType == cmStateEnums::STATIC_LIBRARY) { tmpOutputFile += this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_PREFIX"); tmpOutputFile += targetName; tmpOutputFile += this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_SUFFIX"); } // a list of directories where to search for the compilation result // at first directly in the binary dir std::vector searchDirs; searchDirs.emplace_back(); cmValue config = this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION"); // if a config was specified try that first if (cmNonempty(config)) { std::string tmp = cmStrCat('/', *config); searchDirs.emplace_back(std::move(tmp)); } searchDirs.emplace_back("/Debug"); // handle app-bundles (for targeting apple-platforms) std::string app = "/" + targetName + ".app"; if (cmNonempty(config)) { std::string tmp = cmStrCat('/', *config, app); searchDirs.emplace_back(std::move(tmp)); } std::string tmp = "/Debug" + app; searchDirs.emplace_back(std::move(tmp)); searchDirs.emplace_back(std::move(app)); searchDirs.emplace_back("/Development"); for (std::string const& sdir : searchDirs) { std::string command = cmStrCat(this->BinaryDirectory, sdir, tmpOutputFile); if (cmSystemTools::FileExists(command)) { this->OutputFile = cmSystemTools::CollapseFullPath(command); return; } } std::ostringstream emsg; emsg << "Unable to find the executable at any of:\n"; emsg << cmWrap(" " + this->BinaryDirectory, searchDirs, tmpOutputFile, "\n") << "\n"; this->FindErrorMessage = emsg.str(); }