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

Merge topic 'static_library_flags' 

33e6e0b VS6: Add handling of CMAKE_*_LINKER_FLAGS_<CONFIG> variables
152dfda Add additonal tests for the linker flags
20ed496 Add documentation for the missing CMAKE_*_LINKER_FLAGS_* variables
54f7019 Add CMAKE_STATIC_LINKER_FLAGS to CMakeCommonLanguageInclude
2a43c30 Add support for CMAKE_STATIC_LINKER_FLAGS
14bbf83 Unify the way the flags of a static library are read
This commit is contained in:
Brad King 2013-07-31 08:49:01 -04:00 committed by CMake Topic Stage
parent 58c5dc37d3 33e6e0b9c2
commit e3b6ab92db
13 changed files with 223 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Modules/CMakeCommonLanguageInclude.cmake
View File

@ -68,6 +68,19 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
"Flags used by the linker during Release with Debug Info builds.")
set (CMAKE_STATIC_LINKER_FLAGS_DEBUG ${CMAKE_STATIC_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
"Flags used by the linker during debug builds.")
set (CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL ${CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL_INIT}
CACHE STRING
"Flags used by the linker during release minsize builds.")
set (CMAKE_STATIC_LINKER_FLAGS_RELEASE ${CMAKE_STATIC_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
"Flags used by the linker during release builds.")
set (CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
"Flags used by the linker during Release with Debug Info builds.")
endif()
# shared linker flags
set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
@ -77,6 +90,10 @@ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
CACHE STRING "Flags used by the linker during the creation of modules.")
# static linker flags
set (CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS_INIT}"
CACHE STRING "Flags used by the linker during the creation of static libraries.")
set(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL
"What is the target build tool cmake is generating for.")
@ -103,5 +120,10 @@ CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
CMAKE_MODULE_LINKER_FLAGS_RELEASE
CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_STATIC_LINKER_FLAGS
CMAKE_STATIC_LINKER_FLAGS_DEBUG
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
CMAKE_STATIC_LINKER_FLAGS_RELEASE
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
)

43
Source/cmDocumentVariables.cxx
View File

@ -1428,6 +1428,49 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"Same as CMAKE_C_FLAGS_* but used by the linker "
"when creating executables.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_MODULE_LINKER_FLAGS", cmProperty::VARIABLE,
"Linker flags to be used to create modules.",
"These flags will be used by the linker when creating a module."
,false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_MODULE_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
"Flags to be used when linking a module.",
"Same as CMAKE_C_FLAGS_* but used by the linker "
"when creating modules.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_SHARED_LINKER_FLAGS", cmProperty::VARIABLE,
"Linker flags to be used to create shared libraries.",
"These flags will be used by the linker when creating a shared library."
,false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_SHARED_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
"Flags to be used when linking a shared library.",
"Same as CMAKE_C_FLAGS_* but used by the linker "
"when creating shared libraries.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_STATIC_LINKER_FLAGS", cmProperty::VARIABLE,
"Linker flags to be used to create static libraries.",
"These flags will be used by the linker when creating a static library."
,false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_STATIC_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
"Flags to be used when linking a static library.",
"Same as CMAKE_C_FLAGS_* but used by the linker "
"when creating static libraries.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_LIBRARY_PATH_FLAG", cmProperty::VARIABLE,
"The flag to be used to add a library search path to a compiler.",

34
Source/cmGlobalXCodeGenerator.cxx
View File

@ -1769,27 +1769,31 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
configName);
}
const char* linkFlagsProp = "LINK_FLAGS";
if(target.GetType() == cmTarget::OBJECT_LIBRARY ||
target.GetType() == cmTarget::STATIC_LIBRARY)
{
linkFlagsProp = "STATIC_LIBRARY_FLAGS";
this->CurrentLocalGenerator
->GetStaticLibraryFlags(extraLinkOptions,
cmSystemTools::UpperCase(configName),
&target);
}
const char* targetLinkFlags = target.GetProperty(linkFlagsProp);
if(targetLinkFlags)
else
{
extraLinkOptions += " ";
extraLinkOptions += targetLinkFlags;
}
if(configName && *configName)
{
std::string linkFlagsVar = linkFlagsProp;
linkFlagsVar += "_";
linkFlagsVar += cmSystemTools::UpperCase(configName);
if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str()))
const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
if(targetLinkFlags)
{
extraLinkOptions += " ";
extraLinkOptions += linkFlags;
this->CurrentLocalGenerator->
AppendFlags(extraLinkOptions, targetLinkFlags);
}
if(configName && *configName)
{
std::string linkFlagsVar = "LINK_FLAGS_";
linkFlagsVar += cmSystemTools::UpperCase(configName);
if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str()))
{
this->CurrentLocalGenerator->
AppendFlags(extraLinkOptions, linkFlags);
}
}
}

40
Source/cmLocalGenerator.cxx
View File

@ -1541,6 +1541,25 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
}
}
void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags,
std::string const& config,
cmTarget* target)
{
this->AppendFlags(flags,
this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"));
if(!config.empty())
{
std::string name = "CMAKE_STATIC_LINKER_FLAGS_" + config;
this->AppendFlags(flags, this->Makefile->GetSafeDefinition(name.c_str()));
}
this->AppendFlags(flags, target->GetProperty("STATIC_LIBRARY_FLAGS"));
if(!config.empty())
{
std::string name = "STATIC_LIBRARY_FLAGS_" + config;
this->AppendFlags(flags, target->GetProperty(name.c_str()));
}
}
void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
std::string& flags,
std::string& linkFlags,
@ -1557,26 +1576,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
switch(target->GetType())
{
case cmTarget::STATIC_LIBRARY:
{
const char* targetLinkFlags =
target->GetProperty("STATIC_LIBRARY_FLAGS");
if(targetLinkFlags)
{
linkFlags += targetLinkFlags;
linkFlags += " ";
}
if(!buildType.empty())
{
std::string build = "STATIC_LIBRARY_FLAGS_";
build += buildType;
targetLinkFlags = target->GetProperty(build.c_str());
if(targetLinkFlags)
{
linkFlags += targetLinkFlags;
linkFlags += " ";
}
}
}
this->GetStaticLibraryFlags(linkFlags, buildType, target->Target);
break;
case cmTarget::MODULE_LIBRARY:
libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";

5
Source/cmLocalGenerator.h
View File

@ -348,6 +348,11 @@ public:
std::string const& dir_max,
bool* hasSourceExtension = 0);
/** Fill out the static linker flags for the given target. */
void GetStaticLibraryFlags(std::string& flags,
std::string const& config,
cmTarget* target);
/** Fill out these strings for the given target. Libraries to link,
* flags, and linkflags. */
void GetTargetFlags(std::string& linkLibs,

101
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1171,18 +1171,42 @@ void cmLocalVisualStudio6Generator
std::string extraLinkOptionsRelWithDebInfo;
if(target.GetType() == cmTarget::EXECUTABLE)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
extraLinkOptionsDebug = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_DEBUG");
extraLinkOptionsRelease = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELEASE");
extraLinkOptionsMinSizeRel = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_MINSIZEREL");
extraLinkOptionsRelWithDebInfo = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO");
}
if(target.GetType() == cmTarget::SHARED_LIBRARY)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
extraLinkOptionsDebug = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_DEBUG");
extraLinkOptionsRelease = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELEASE");
extraLinkOptionsMinSizeRel = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL");
extraLinkOptionsRelWithDebInfo = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO");
}
if(target.GetType() == cmTarget::MODULE_LIBRARY)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
extraLinkOptionsDebug = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS_DEBUG");
extraLinkOptionsRelease = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS_RELEASE");
extraLinkOptionsMinSizeRel = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL");
extraLinkOptionsRelWithDebInfo = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO");
}
// Get extra linker options for this target.
@ -1435,38 +1459,39 @@ void cmLocalVisualStudio6Generator
std::string staticLibOptionsRelWithDebInfo;
if(target.GetType() == cmTarget::STATIC_LIBRARY )
{
if(const char* libflags = target.GetProperty("STATIC_LIBRARY_FLAGS"))
{
staticLibOptions = libflags;
staticLibOptionsDebug = libflags;
staticLibOptionsRelease = libflags;
staticLibOptionsMinSizeRel = libflags;
staticLibOptionsRelWithDebInfo = libflags;
}
if(const char* libflagsDebug =
target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"))
{
staticLibOptionsDebug += " ";
staticLibOptionsDebug = libflagsDebug;
}
if(const char* libflagsRelease =
target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"))
{
staticLibOptionsRelease += " ";
staticLibOptionsRelease = libflagsRelease;
}
if(const char* libflagsMinSizeRel =
target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"))
{
staticLibOptionsMinSizeRel += " ";
staticLibOptionsMinSizeRel = libflagsMinSizeRel;
}
if(const char* libflagsRelWithDebInfo =
target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"))
{
staticLibOptionsRelWithDebInfo += " ";
staticLibOptionsRelWithDebInfo = libflagsRelWithDebInfo;
}
const char *libflagsGlobal =
this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS");
this->AppendFlags(staticLibOptions, libflagsGlobal);
this->AppendFlags(staticLibOptionsDebug, libflagsGlobal);
this->AppendFlags(staticLibOptionsRelease, libflagsGlobal);
this->AppendFlags(staticLibOptionsMinSizeRel, libflagsGlobal);
this->AppendFlags(staticLibOptionsRelWithDebInfo, libflagsGlobal);
this->AppendFlags(staticLibOptionsDebug, this->Makefile->
GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_DEBUG"));
this->AppendFlags(staticLibOptionsRelease, this->Makefile->
GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELEASE"));
this->AppendFlags(staticLibOptionsMinSizeRel, this->Makefile->
GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL"));
this->AppendFlags(staticLibOptionsRelWithDebInfo, this->Makefile->
GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO"));
const char *libflags = target.GetProperty("STATIC_LIBRARY_FLAGS");
this->AppendFlags(staticLibOptions, libflags);
this->AppendFlags(staticLibOptionsDebug, libflags);
this->AppendFlags(staticLibOptionsRelease, libflags);
this->AppendFlags(staticLibOptionsMinSizeRel, libflags);
this->AppendFlags(staticLibOptionsRelWithDebInfo, libflags);
this->AppendFlags(staticLibOptionsDebug,
target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"));
this->AppendFlags(staticLibOptionsRelease,
target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"));
this->AppendFlags(staticLibOptionsMinSizeRel,
target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"));
this->AppendFlags(staticLibOptionsRelWithDebInfo,
target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"));
std::string objects;
this->OutputObjects(target, "LIB", objects);
if(!objects.empty())

12
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -1039,17 +1039,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
}
std::string libflags;
if(const char* flags = target.GetProperty("STATIC_LIBRARY_FLAGS"))
{
libflags += flags;
}
std::string libFlagsConfig = "STATIC_LIBRARY_FLAGS_";
libFlagsConfig += configTypeUpper;
if(const char* flagsConfig = target.GetProperty(libFlagsConfig.c_str()))
{
libflags += " ";
libflags += flagsConfig;
}
this->GetStaticLibraryFlags(libflags, configTypeUpper, &target);
if(!libflags.empty())
{
fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";

8
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -144,12 +144,8 @@ void cmMakefileLibraryTargetGenerator::WriteStaticLibraryRules()
}
std::string extraFlags;
this->LocalGenerator->AppendFlags
(extraFlags,this->Target->GetProperty("STATIC_LIBRARY_FLAGS"));
std::string staticLibraryFlagsConfig = "STATIC_LIBRARY_FLAGS_";
staticLibraryFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
this->LocalGenerator->AppendFlags
(extraFlags, this->Target->GetProperty(staticLibraryFlagsConfig.c_str()));
this->LocalGenerator->GetStaticLibraryFlags(extraFlags,
cmSystemTools::UpperCase(this->ConfigName), this->Target);
this->WriteLibraryRules(linkRuleVar.c_str(), extraFlags.c_str(), false);
}

13
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -1417,20 +1417,17 @@ cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config)
{
return;
}
const char* libflags = this->Target->GetProperty("STATIC_LIBRARY_FLAGS");
std::string flagsConfigVar = "STATIC_LIBRARY_FLAGS_";
flagsConfigVar += cmSystemTools::UpperCase(config);
const char* libflagsConfig =
this->Target->GetProperty(flagsConfigVar.c_str());
if(libflags || libflagsConfig)
std::string libflags;
this->LocalGenerator->GetStaticLibraryFlags(libflags,
cmSystemTools::UpperCase(config), this->Target);
if(!libflags.empty())
{
this->WriteString("<Lib>\n", 2);
cmVisualStudioGeneratorOptions
libOptions(this->LocalGenerator,
cmVisualStudioGeneratorOptions::Linker,
cmVSGetLibFlagTable(this->LocalGenerator), 0, this);
libOptions.Parse(libflags?libflags:"");
libOptions.Parse(libflagsConfig?libflagsConfig:"");
libOptions.Parse(libflags.c_str());
libOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", "");
libOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("</Lib>\n", 2);

14
Tests/CMakeLists.txt
View File

@ -394,10 +394,20 @@ if(BUILD_TESTING)
endmacro()
ADD_LINK_FLAGS_TEST(lib prepare)
ADD_LINK_FLAGS_TEST(dll lib)
ADD_LINK_FLAGS_TEST(exe dll)
ADD_LINK_FLAGS_TEST(mod dll)
ADD_LINK_FLAGS_TEST(exe mod)
ADD_LINK_FLAGS_TEST(lib_config exe)
ADD_LINK_FLAGS_TEST(dll_config lib_config)
ADD_LINK_FLAGS_TEST(exe_config dll_config)
ADD_LINK_FLAGS_TEST(mod_config dll_config)
ADD_LINK_FLAGS_TEST(exe_config mod_config)
ADD_LINK_FLAGS_TEST(lib_flags exe_config)
ADD_LINK_FLAGS_TEST(dll_flags lib_flags)
ADD_LINK_FLAGS_TEST(mod_flags dll_flags)
ADD_LINK_FLAGS_TEST(exe_flags mod_flags)
ADD_LINK_FLAGS_TEST(lib_flags_config exe_flags)
ADD_LINK_FLAGS_TEST(dll_flags_config lib_flags_config)
ADD_LINK_FLAGS_TEST(mod_flags_config dll_flags_config)
ADD_LINK_FLAGS_TEST(exe_flags_config mod_flags_config)
# If we are running right now with a UnixMakefiles based generator,
# build the "Simple" test with the ExtraGenerators, if available

9
Tests/LinkFlags/CMakeLists.txt
View File

@ -13,6 +13,9 @@ set_property(TARGET LinkFlags_lib PROPERTY STATIC_LIBRARY_FLAGS ${pre}BADFLAG${o
add_library(LinkFlags_dll SHARED LinkFlagsLib.c)
set_property(TARGET LinkFlags_dll PROPERTY LINK_FLAGS ${pre}BADFLAG${obj})
add_library(LinkFlags_mod MODULE LinkFlagsLib.c)
set_property(TARGET LinkFlags_mod PROPERTY LINK_FLAGS ${pre}BADFLAG${obj})
add_executable(LinkFlags_exe LinkFlagsExe.c)
set_property(TARGET LinkFlags_exe PROPERTY LINK_FLAGS ${pre}BADFLAG${obj})
@ -22,7 +25,13 @@ set_property(TARGET LinkFlags_lib_config PROPERTY STATIC_LIBRARY_FLAGS_${TEST_CO
add_library(LinkFlags_dll_config SHARED LinkFlagsLib.c)
set_property(TARGET LinkFlags_dll_config PROPERTY LINK_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG_${TEST_CONFIG}${obj})
add_library(LinkFlags_mod_config MODULE LinkFlagsLib.c)
set_property(TARGET LinkFlags_mod_config PROPERTY LINK_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG_${TEST_CONFIG}${obj})
add_executable(LinkFlags_exe_config LinkFlagsExe.c)
set_property(TARGET LinkFlags_exe_config PROPERTY LINK_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG_${TEST_CONFIG}${obj})
add_executable(LinkFlags LinkFlags.c)
add_subdirectory(LinkerFlags)
add_subdirectory(LinkerFlagsConfig)

11
Tests/LinkFlags/LinkerFlags/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
set(CMAKE_STATIC_LINKER_FLAGS ${pre}BADFLAG${obj})
add_library(LinkFlags_lib_flags STATIC ../LinkFlagsLib.c)
set(CMAKE_SHARED_LINKER_FLAGS ${pre}BADFLAG${obj})
add_library(LinkFlags_dll_flags SHARED ../LinkFlagsLib.c)
set(CMAKE_MODULE_LINKER_FLAGS ${pre}BADFLAG${obj})
add_library(LinkFlags_mod_flags MODULE ../LinkFlagsLib.c)
set(CMAKE_EXE_LINKER_FLAGS ${pre}BADFLAG${obj})
add_executable(LinkFlags_exe_flags ../LinkFlagsExe.c)

11
Tests/LinkFlags/LinkerFlagsConfig/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
set(CMAKE_STATIC_LINKER_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG${obj})
add_library(LinkFlags_lib_flags_config STATIC ../LinkFlagsLib.c)
set(CMAKE_SHARED_LINKER_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG${obj})
add_library(LinkFlags_dll_flags_config SHARED ../LinkFlagsLib.c)
set(CMAKE_MODULE_LINKER_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG${obj})
add_library(LinkFlags_mod_flags_config MODULE ../LinkFlagsLib.c)
set(CMAKE_EXE_LINKER_FLAGS_${TEST_CONFIG_UPPER} ${pre}BADFLAG${obj})
add_executable(LinkFlags_exe_flags_config ../LinkFlagsExe.c)