kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'try_compile-custom-variables' 

d256ba07 try_compile: Optionally forward custom platform variables to test project
fb4791b3 cmCoreTryCompile: Refactor forwarding of variables to test project
This commit is contained in:
Brad King 2016-05-26 09:52:12 -04:00 committed by CMake Topic Stage
parent 67cc866877 d256ba078a
commit 36d9a01a31
7 changed files with 118 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Help/command/try_compile.rst
View File

@ -115,3 +115,7 @@ a build configuration.
Set the :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` variable to specify
the type of target used for the source file signature.
Set the :variable:`CMAKE_TRY_COMPILE_PLATFORM_VARIABLES` variable to specify
variables that must be propagated into the test project. This variable is
meant for use only in toolchain files.

1
Help/manual/cmake-variables.7.rst
View File

@ -298,6 +298,7 @@ Variables that Control the Build
/variable/CMAKE_STATIC_LINKER_FLAGS_CONFIG
/variable/CMAKE_STATIC_LINKER_FLAGS
/variable/CMAKE_TRY_COMPILE_CONFIGURATION
/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
/variable/CMAKE_TRY_COMPILE_TARGET_TYPE
/variable/CMAKE_USE_RELATIVE_PATHS
/variable/CMAKE_VISIBILITY_INLINES_HIDDEN

7
Help/release/dev/try_compile-custom-variables.rst Normal file
View File

@ -0,0 +1,7 @@
try_compile-custom-variables
----------------------------
* A :variable:`CMAKE_TRY_COMPILE_PLATFORM_VARIABLES` variable was
added for use by toolchain files to specify platform-specific
variables that must be propagated by the :command:`try_compile`
command into test projects.

10
Help/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES.rst Normal file
View File

@ -0,0 +1,10 @@
CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
------------------------------------
List of variables that the :command:`try_compile` command source file signature
must propagate into the test project in order to target the same platform as
the host project.
This variable should not be set by project code. It is meant to be set by
CMake's platform information modules for the current toolchain, or by a
toolchain file when used with :variable:`CMAKE_TOOLCHAIN_FILE`.

143
Source/cmCoreTryCompile.cxx
View File

@ -20,6 +20,30 @@
#include <assert.h>
static std::string const kCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN =
"CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN";
static std::string const kCMAKE_C_COMPILER_TARGET = "CMAKE_C_COMPILER_TARGET";
static std::string const kCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN =
"CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN";
static std::string const kCMAKE_CXX_COMPILER_TARGET =
"CMAKE_CXX_COMPILER_TARGET";
static std::string const kCMAKE_ENABLE_EXPORTS = "CMAKE_ENABLE_EXPORTS";
static std::string const kCMAKE_LINK_SEARCH_END_STATIC =
"CMAKE_LINK_SEARCH_END_STATIC";
static std::string const kCMAKE_LINK_SEARCH_START_STATIC =
"CMAKE_LINK_SEARCH_START_STATIC";
static std::string const kCMAKE_OSX_ARCHITECTURES = "CMAKE_OSX_ARCHITECTURES";
static std::string const kCMAKE_OSX_DEPLOYMENT_TARGET =
"CMAKE_OSX_DEPLOYMENT_TARGET";
static std::string const kCMAKE_OSX_SYSROOT = "CMAKE_OSX_SYSROOT";
static std::string const kCMAKE_POSITION_INDEPENDENT_CODE =
"CMAKE_POSITION_INDEPENDENT_CODE";
static std::string const kCMAKE_SYSROOT = "CMAKE_SYSROOT";
static std::string const kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES =
"CMAKE_TRY_COMPILE_OSX_ARCHITECTURES";
static std::string const kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES =
"CMAKE_TRY_COMPILE_PLATFORM_VARIABLES";
int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
bool isTryRun)
{
@ -383,76 +407,51 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
fname.c_str());
}
/* 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 (this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_OSX_ARCHITECTURES") !=
0) {
std::string flag = "-DCMAKE_OSX_ARCHITECTURES=";
flag += this->Makefile->GetSafeDefinition(
"CMAKE_TRY_COMPILE_OSX_ARCHITECTURES");
cmakeFlags.push_back(flag);
} else if (this->Makefile->GetDefinition("CMAKE_OSX_ARCHITECTURES") != 0) {
std::string flag = "-DCMAKE_OSX_ARCHITECTURES=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES");
cmakeFlags.push_back(flag);
}
/* on APPLE also pass CMAKE_OSX_SYSROOT to the try_compile */
if (this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT") != 0) {
std::string flag = "-DCMAKE_OSX_SYSROOT=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_SYSROOT");
cmakeFlags.push_back(flag);
}
/* on APPLE also pass CMAKE_OSX_DEPLOYMENT_TARGET to the try_compile */
if (this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET") != 0) {
std::string flag = "-DCMAKE_OSX_DEPLOYMENT_TARGET=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
cmakeFlags.push_back(flag);
}
if (const char* cxxDef =
this->Makefile->GetDefinition("CMAKE_CXX_COMPILER_TARGET")) {
std::string flag = "-DCMAKE_CXX_COMPILER_TARGET=";
flag += cxxDef;
cmakeFlags.push_back(flag);
}
if (const char* cDef =
this->Makefile->GetDefinition("CMAKE_C_COMPILER_TARGET")) {
std::string flag = "-DCMAKE_C_COMPILER_TARGET=";
flag += cDef;
cmakeFlags.push_back(flag);
}
if (const char* tcxxDef = this->Makefile->GetDefinition(
"CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN")) {
std::string flag = "-DCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN=";
flag += tcxxDef;
cmakeFlags.push_back(flag);
}
if (const char* tcDef = this->Makefile->GetDefinition(
"CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN")) {
std::string flag = "-DCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN=";
flag += tcDef;
cmakeFlags.push_back(flag);
}
if (const char* rootDef = this->Makefile->GetDefinition("CMAKE_SYSROOT")) {
std::string flag = "-DCMAKE_SYSROOT=";
flag += rootDef;
cmakeFlags.push_back(flag);
}
if (this->Makefile->GetDefinition("CMAKE_POSITION_INDEPENDENT_CODE") !=
0) {
fprintf(fout, "set(CMAKE_POSITION_INDEPENDENT_CODE \"ON\")\n");
}
if (const char* lssDef =
this->Makefile->GetDefinition("CMAKE_LINK_SEARCH_START_STATIC")) {
fprintf(fout, "set(CMAKE_LINK_SEARCH_START_STATIC \"%s\")\n", lssDef);
}
if (const char* lssDef =
this->Makefile->GetDefinition("CMAKE_LINK_SEARCH_END_STATIC")) {
fprintf(fout, "set(CMAKE_LINK_SEARCH_END_STATIC \"%s\")\n", lssDef);
// Forward a set of variables to the inner project cache.
{
std::set<std::string> vars;
vars.insert(kCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN);
vars.insert(kCMAKE_C_COMPILER_TARGET);
vars.insert(kCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN);
vars.insert(kCMAKE_CXX_COMPILER_TARGET);
vars.insert(kCMAKE_ENABLE_EXPORTS);
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_POSITION_INDEPENDENT_CODE);
vars.insert(kCMAKE_SYSROOT);
if (const char* varListStr = this->Makefile->GetDefinition(
kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES)) {
std::vector<std::string> varList;
cmSystemTools::ExpandListArgument(varListStr, varList);
vars.insert(varList.begin(), varList.end());
}
/* 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 (const char* tcArchs = this->Makefile->GetDefinition(
kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES)) {
vars.erase(kCMAKE_OSX_ARCHITECTURES);
std::string flag = "-DCMAKE_OSX_ARCHITECTURES=" + std::string(tcArchs);
cmakeFlags.push_back(flag);
}
for (std::set<std::string>::iterator vi = vars.begin(); vi != vars.end();
++vi) {
std::string const& var = *vi;
if (const char* val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + val;
cmakeFlags.push_back(flag);
}
}
}
/* Set the appropriate policy information for ENABLE_EXPORTS */
@ -461,10 +460,6 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
cmPolicies::NEW
? "NEW"
: "OLD");
if (const char* ee =
this->Makefile->GetDefinition("CMAKE_ENABLE_EXPORTS")) {
fprintf(fout, "set(CMAKE_ENABLE_EXPORTS %s)\n", ee);
}
if (targetType == cmState::EXECUTABLE) {
/* Put the executable at a known location (for COPY_FILE). */

23
Tests/RunCMake/try_compile/PlatformVariables.cmake Normal file
View File

@ -0,0 +1,23 @@
enable_language(C)
# Normally this variable should be set by a platform information module or
# a toolchain file, but for purposes of this test we simply set it here.
set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES MY_CUSTOM_VARIABLE)
set(MY_CUSTOM_VARIABLE SOME_VALUE)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()
# Check that the cache was populated with our custom variable.
file(STRINGS ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CMakeCache.txt entries
REGEX MY_CUSTOM_VARIABLE:UNINITIALIZED=${MY_CUSTOM_VARIABLE}
)
if(NOT entries)
message(FATAL_ERROR "try_compile did not populate cache as expected")
endif()

4
Tests/RunCMake/try_compile/RunCMakeTest.cmake
View File

@ -16,6 +16,10 @@ run_cmake(BadSources2)
run_cmake(NonSourceCopyFile)
run_cmake(NonSourceCompileDefinitions)
set(RunCMake_TEST_OPTIONS --debug-trycompile)
run_cmake(PlatformVariables)
unset(RunCMake_TEST_OPTIONS)
run_cmake(TargetTypeExe)
run_cmake(TargetTypeInvalid)
run_cmake(TargetTypeStatic)