From bd3496300262bd26073ce03e020731c592249148 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Wed, 30 May 2012 14:13:09 -0400 Subject: [PATCH] Refactor generation of shared library flags CMAKE_SHARED_LIBRARY__FLAGS has flags on various platforms for a variety of purposes that are correlated with shared libraries but not exclusive to them. Refactor generation of these flags to use new purpose-specific platform variables CMAKE__COMPILE_OPTIONS_DLL CMAKE__COMPILE_OPTIONS_PIC CMAKE__COMPILE_OPTIONS_PIE Activate the DLL flags specifically for shared libraries. Add a new POSITION_INDEPENDENT_CODE target property to activate PIC/PIE flags, and default to true for shared libraries to preserve default behavior. Initialize the new property from CMAKE_POSITION_INDEPENDENT_CODE to allow easy global configuration in projects. Although the default behavior is unchanged by this refactoring, the new approach ignores CMAKE_SHARED_LIBRARY__FLAGS completely. We must leave it set in case projects reference the value. Furthermore, if a project modifies CMAKE_SHARED_LIBRARY__FLAGS it expects the new value to be used. Add policy CMP0018 to handle compatibility with projects that modify this platform variable. Add a PositionIndependentCode test on platforms where we can get meaningful results. --- Source/cmCoreTryCompile.cxx | 4 + Source/cmDocumentVariables.cxx | 8 ++ Source/cmGlobalGenerator.cxx | 21 ++++ Source/cmGlobalGenerator.h | 3 + Source/cmGlobalXCodeGenerator.cxx | 4 +- Source/cmLocalGenerator.cxx | 111 +++++++++++++++++- Source/cmLocalGenerator.h | 8 +- Source/cmMakefileTargetGenerator.cxx | 6 +- Source/cmNinjaTargetGenerator.cxx | 7 +- Source/cmPolicies.cxx | 28 +++++ Source/cmPolicies.h | 3 + Source/cmTarget.cxx | 15 +++ Tests/CMakeLists.txt | 18 +++ .../PositionIndependentTargets/CMakeLists.txt | 13 ++ .../global/CMakeLists.txt | 37 ++++++ Tests/PositionIndependentTargets/main.cpp | 2 + Tests/PositionIndependentTargets/pic_lib.cpp | 12 ++ Tests/PositionIndependentTargets/pic_main.cpp | 4 + Tests/PositionIndependentTargets/pic_test.h | 20 ++++ .../targets/CMakeLists.txt | 20 ++++ 20 files changed, 325 insertions(+), 19 deletions(-) create mode 100644 Tests/PositionIndependentTargets/CMakeLists.txt create mode 100644 Tests/PositionIndependentTargets/global/CMakeLists.txt create mode 100644 Tests/PositionIndependentTargets/main.cpp create mode 100644 Tests/PositionIndependentTargets/pic_lib.cpp create mode 100644 Tests/PositionIndependentTargets/pic_main.cpp create mode 100644 Tests/PositionIndependentTargets/pic_test.h create mode 100644 Tests/PositionIndependentTargets/targets/CMakeLists.txt diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index ed485e351..1ae70350b 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -281,6 +281,10 @@ int cmCoreTryCompile::TryCompileCode(std::vector const& argv) flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_DEPLOYMENT_TARGET"); cmakeFlags.push_back(flag); } + if(this->Makefile->GetDefinition("CMAKE_POSITION_INDEPENDENT_CODE")!=0) + { + fprintf(fout, "SET(CMAKE_POSITION_INDEPENDENT_CODE \"ON\")\n"); + } /* Use a random file name to avoid rapid creation and deletion of the same executable name (some filesystems fail on that). */ diff --git a/Source/cmDocumentVariables.cxx b/Source/cmDocumentVariables.cxx index 9e33d7578..592d93164 100644 --- a/Source/cmDocumentVariables.cxx +++ b/Source/cmDocumentVariables.cxx @@ -1350,6 +1350,14 @@ void cmDocumentVariables::DefineVariables(cmake* cm) "See that target property for additional information.", false, "Variables that Control the Build"); + cm->DefineProperty + ("CMAKE_POSITION_INDEPENDENT_FLAGS", cmProperty::VARIABLE, + "Default value for POSITION_INDEPENDENT_CODE of targets.", + "This variable is used to initialize the " + "POSITION_INDEPENDENT_CODE property on all the targets. " + "See that target property for additional information.", + false, + "Variables that Control the Build"); // Variables defined when the a language is enabled These variables will // also be defined whenever CMake has loaded its support for compiling (LANG) diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index b06cdb4ee..f3a70904e 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -586,6 +586,16 @@ cmGlobalGenerator::EnableLanguage(std::vectorconst& languages, } } // end if in try compile } // end need test language + // Store the shared library flags so that we can satisfy CMP0018 + std::string sharedLibFlagsVar = "CMAKE_SHARED_LIBRARY_"; + sharedLibFlagsVar += lang; + sharedLibFlagsVar += "_FLAGS"; + const char* sharedLibFlags = + mf->GetSafeDefinition(sharedLibFlagsVar.c_str()); + if (sharedLibFlags) + { + this->LanguageToOriginalSharedLibFlags[lang] = sharedLibFlags; + } } // end for each language // Now load files that can override any settings on the platform or for @@ -2106,6 +2116,17 @@ cmGlobalGenerator::GenerateRuleFile(std::string const& output) const return ruleFile; } +//---------------------------------------------------------------------------- +std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage( + std::string const& l) +{ + if(this->LanguageToOriginalSharedLibFlags.count(l) > 0) + { + return this->LanguageToOriginalSharedLibFlags[l]; + } + return ""; +} + //---------------------------------------------------------------------------- void cmGlobalGenerator::AppendDirectoryForConfig(const char*, const char*, const char*, std::string&) diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 5254b89a6..0ac38a0a5 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -277,6 +277,8 @@ public: i.e. "Can I build Debug and Release in the same tree?" */ virtual bool IsMultiConfig() { return false; } + std::string GetSharedLibFlagsForLanguage(std::string const& lang); + /** Generate an .rule file path for a given command output. */ virtual std::string GenerateRuleFile(std::string const& output) const; @@ -357,6 +359,7 @@ private: std::map LanguageToOutputExtension; std::map ExtensionToLanguage; std::map LanguageToLinkerPreference; + std::map LanguageToOriginalSharedLibFlags; // Record hashes for rules and outputs. struct RuleHash { char Data[32]; }; diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 522f3daef..938977bfb 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -1594,14 +1594,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, if(strcmp(lang, "CXX") == 0) { this->CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName); - this->CurrentLocalGenerator->AddSharedFlags(cflags, lang, shared); + this->CurrentLocalGenerator->AddCMP0018Flags(cflags, &target, "C"); } // Add language-specific flags. this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName); // Add shared-library flags if needed. - this->CurrentLocalGenerator->AddSharedFlags(flags, lang, shared); + this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target, lang); } else if(binary) { diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 8265d72b4..5fc5f057c 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1549,12 +1549,6 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, return; } this->AddLanguageFlags(flags, linkLanguage, buildType.c_str()); - std::string sharedFlagsVar = "CMAKE_SHARED_LIBRARY_"; - sharedFlagsVar += linkLanguage; - sharedFlagsVar += "_FLAGS"; - flags += " "; - flags += this->Makefile->GetSafeDefinition(sharedFlagsVar.c_str()); - flags += " "; cmOStringStream linklibs; this->OutputLinkLibraries(linklibs, target, false); linkLibs = linklibs.str(); @@ -1962,6 +1956,111 @@ void cmLocalGenerator::AddSharedFlags(std::string& flags, } } +//---------------------------------------------------------------------------- +void cmLocalGenerator::AddCMP0018Flags(std::string &flags, cmTarget* target, + std::string const& lang) +{ + int targetType = target->GetType(); + + bool shared = ((targetType == cmTarget::SHARED_LIBRARY) || + (targetType == cmTarget::MODULE_LIBRARY)); + + if (this->GetShouldUseOldFlags(shared, lang)) + { + this->AddSharedFlags(flags, lang.c_str(), shared); + } + else + { + // Add position independendent flags, if needed. + if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE")) + { + this->AddPositionIndependentFlags(flags, lang, targetType); + } + if (shared) + { + this->AppendFeatureOptions(flags, lang.c_str(), "DLL"); + } + } +} + +//---------------------------------------------------------------------------- +bool cmLocalGenerator::GetShouldUseOldFlags(bool shared, + const std::string &lang) const +{ + std::string originalFlags = + this->GlobalGenerator->GetSharedLibFlagsForLanguage(lang); + if (shared) + { + std::string flagsVar = "CMAKE_SHARED_LIBRARY_"; + flagsVar += lang; + flagsVar += "_FLAGS"; + const char* flags = + this->Makefile->GetSafeDefinition(flagsVar.c_str()); + + if (flags && flags != originalFlags) + { + switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0018)) + { + case cmPolicies::WARN: + { + cmOStringStream e; + e << "Variable " << flagsVar << " has been modified. CMake " + "will ignore the POSITION_INDEPENDENT_CODE target property for " + "shared libraries and will use the " << flagsVar << " variable " + "instead. This may cause errors if the original content of " + << flagsVar << " was removed.\n" + << this->Makefile->GetPolicies()->GetPolicyWarning( + cmPolicies::CMP0018); + + this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str()); + // fall through to OLD behaviour + } + case cmPolicies::OLD: + return true; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + case cmPolicies::NEW: + default: + return false; + } + } + } + return false; +} + +//---------------------------------------------------------------------------- +void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags, + std::string const& lang, + int targetType) +{ + const char* picFlags = 0; + + if(targetType == cmTarget::EXECUTABLE) + { + std::string flagsVar = "CMAKE_"; + flagsVar += lang; + flagsVar += "_COMPILE_OPTIONS_PIE"; + picFlags = this->Makefile->GetSafeDefinition(flagsVar.c_str()); + } + if (!picFlags) + { + std::string flagsVar = "CMAKE_"; + flagsVar += lang; + flagsVar += "_COMPILE_OPTIONS_PIC"; + picFlags = this->Makefile->GetSafeDefinition(flagsVar.c_str()); + } + if (picFlags) + { + std::vector options; + cmSystemTools::ExpandListArgument(picFlags, options); + for(std::vector::const_iterator oi = options.begin(); + oi != options.end(); ++oi) + { + this->AppendFlags(flags, this->EscapeForShell(oi->c_str()).c_str()); + } + } +} + //---------------------------------------------------------------------------- void cmLocalGenerator::AddConfigVariableFlags(std::string& flags, const char* var, diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index cb84a307b..1d8a7d1c2 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -140,7 +140,8 @@ public: void AddLanguageFlags(std::string& flags, const char* lang, const char* config); - void AddSharedFlags(std::string& flags, const char* lang, bool shared); + void AddCMP0018Flags(std::string &flags, cmTarget* target, + std::string const& lang); void AddConfigVariableFlags(std::string& flags, const char* var, const char* config); ///! Append flags to a string. @@ -425,6 +426,11 @@ protected: private: std::string ConvertToOutputForExistingCommon(const char* remote, std::string const& result); + + void AddSharedFlags(std::string& flags, const char* lang, bool shared); + bool GetShouldUseOldFlags(bool shared, const std::string &lang) const; + void AddPositionIndependentFlags(std::string& flags, std::string const& l, + int targetType); }; #endif diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index 408f287bc..df892759f 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -245,9 +245,6 @@ std::string cmMakefileTargetGenerator::GetFlags(const std::string &l) std::string flags; const char *lang = l.c_str(); - bool shared = ((this->Target->GetType() == cmTarget::SHARED_LIBRARY) || - (this->Target->GetType() == cmTarget::MODULE_LIBRARY)); - // Add language feature flags. this->AddFeatureFlags(flags, lang); @@ -260,8 +257,7 @@ std::string cmMakefileTargetGenerator::GetFlags(const std::string &l) this->AddFortranFlags(flags); } - // Add shared-library flags if needed. - this->LocalGenerator->AddSharedFlags(flags, lang, shared); + this->LocalGenerator->AddCMP0018Flags(flags, this->Target, lang); // Add include directory flags. this->AddIncludeFlags(flags, lang); diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 80007f107..b3394bbed 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -140,11 +140,8 @@ cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile *source, // } // Add shared-library flags if needed. - { - bool shared = ((this->Target->GetType() == cmTarget::SHARED_LIBRARY) || - (this->Target->GetType() == cmTarget::MODULE_LIBRARY)); - this->GetLocalGenerator()->AddSharedFlags(flags, language.c_str(), shared); - } + this->LocalGenerator->AddCMP0018Flags(flags, this->Target, + language.c_str()); // TODO: Handle response file. // Add include directory flags. diff --git a/Source/cmPolicies.cxx b/Source/cmPolicies.cxx index 37070b61d..79af4d700 100644 --- a/Source/cmPolicies.cxx +++ b/Source/cmPolicies.cxx @@ -463,6 +463,34 @@ cmPolicies::cmPolicies() "The OLD behaviour is to always prefer files from CMAKE_MODULE_PATH over " "files from the CMake modules directory.", 2,8,4,0, cmPolicies::WARN); + + this->DefinePolicy( + CMP0018, "CMP0018", + "Ignore CMAKE_SHARED_LIBRARY__FLAGS variable.", + "CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries " + "using the value of the undocumented CMAKE_SHARED_LIBRARY__FLAGS " + "platform variable. The variable contained platform-specific flags " + "needed to compile objects for shared libraries. Typically it included " + "a flag such as -fPIC for position independent code but also included " + "other flags needed on certain platforms. CMake 2.8.9 and higher " + "prefer instead to use the POSITION_INDEPENDENT_CODE target property to " + "determine what targets should be position independent, and new " + "undocumented platform variables to select flags while ignoring " + "CMAKE_SHARED_LIBRARY__FLAGS completely." + "\n" + "The default for either approach produces identical compilation flags, " + "but if a project modifies CMAKE_SHARED_LIBRARY__FLAGS from its " + "original value this policy determines which approach to use." + "\n" + "The OLD behavior for this policy is to ignore the " + "POSITION_INDEPENDENT_CODE property for all targets and use the modified " + "value of CMAKE_SHARED_LIBRARY__FLAGS for SHARED and MODULE " + "libraries." + "\n" + "The NEW behavior for this policy is to ignore " + "CMAKE_SHARED_LIBRARY__FLAGS whether it is modified or not and " + "honor the POSITION_INDEPENDENT_CODE target property.", + 2,8,9,0, cmPolicies::WARN); } cmPolicies::~cmPolicies() diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index 3106248c5..6932565ab 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -65,6 +65,9 @@ public: /// target_link_libraries() fails if only argument is not a target CMP0016, CMP0017, ///< Prefer files in CMAKE_ROOT when including from CMAKE_ROOT + CMP0018, ///< Ignore language flags for shared libs, and adhere to + /// POSITION_INDEPENDENT_CODE property and *_COMPILE_OPTIONS_PI{E,C} + /// instead. /** \brief Always the last entry. * diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index c5ef9fff1..4f3f2c572 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -755,6 +755,14 @@ void cmTarget::DefineProperties(cmake *cm) "A target property that can be set to override the prefix " "(such as \"lib\") on a library name."); + cm->DefineProperty + ("POSITION_INDEPENDENT_CODE", cmProperty::TARGET, + "Whether to create a position-independent target", + "The POSITION_INDEPENDENT_CODE property determines whether position " + "independent executables or shared libraries will be created. " + "This property is true by default for SHARED and MODULE library " + "targets and false otherwise."); + cm->DefineProperty ("POST_INSTALL_SCRIPT", cmProperty::TARGET, "Deprecated install support.", @@ -1305,6 +1313,13 @@ void cmTarget::SetMakefile(cmMakefile* mf) this->SetProperty("INCLUDE_DIRECTORIES", this->Makefile->GetProperty("INCLUDE_DIRECTORIES")); + if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY + || this->TargetTypeValue == cmTarget::MODULE_LIBRARY) + { + this->SetProperty("POSITION_INDEPENDENT_CODE", "True"); + } + this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", 0); + // Record current policies for later use. this->PolicyStatusCMP0003 = this->Makefile->GetPolicyStatus(cmPolicies::CMP0003); diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index 5972c195c..68c08a473 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -315,6 +315,24 @@ IF(BUILD_TESTING) ADD_TEST_MACRO(Module.GenerateExportHeader GenerateExportHeader) + if (APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU") + include(CheckCXXCompilerFlag) + check_cxx_compiler_flag(-fPIE run_pic_test) + else() + if (CMAKE_CXX_COMPILER_ID MATCHES "PGI" + OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale" + OR CMAKE_SYSTEM_NAME MATCHES "IRIX64" + OR CMAKE_CXX_COMPILER_ID MATCHES "Intel") + set(run_pic_test 0) + else() + set(run_pic_test 1) + endif() + endif() + + if (run_pic_test) + ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets) + endif() + ADD_TEST(LinkFlags-prepare ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} --build-and-test diff --git a/Tests/PositionIndependentTargets/CMakeLists.txt b/Tests/PositionIndependentTargets/CMakeLists.txt new file mode 100644 index 000000000..eec893d32 --- /dev/null +++ b/Tests/PositionIndependentTargets/CMakeLists.txt @@ -0,0 +1,13 @@ + +cmake_minimum_required(VERSION 2.8) + +project(PositionIndependentTargets) + +include(CheckCXXSourceCompiles) + +include_directories("${CMAKE_CURRENT_SOURCE_DIR}") # For pic_test.h + +add_subdirectory(global) +add_subdirectory(targets) + +add_executable(PositionIndependentTargets main.cpp) diff --git a/Tests/PositionIndependentTargets/global/CMakeLists.txt b/Tests/PositionIndependentTargets/global/CMakeLists.txt new file mode 100644 index 000000000..1d662f8ea --- /dev/null +++ b/Tests/PositionIndependentTargets/global/CMakeLists.txt @@ -0,0 +1,37 @@ + +set(CMAKE_POSITION_INDEPENDENT_CODE True) + +add_executable(test_target_executable_global + "${CMAKE_CURRENT_SOURCE_DIR}/../pic_main.cpp" +) + +add_library(test_target_shared_library_global + SHARED "${CMAKE_CURRENT_SOURCE_DIR}/../pic_lib.cpp" +) +set_target_properties(test_target_shared_library_global + PROPERTIES DEFINE_SYMBOL PIC_TEST_BUILD_DLL +) + +add_library(test_target_static_library_global + STATIC "${CMAKE_CURRENT_SOURCE_DIR}/../pic_lib.cpp" +) +set_target_properties(test_target_static_library_global + PROPERTIES COMPILE_DEFINITIONS PIC_TEST_STATIC_BUILD +) + + +file(READ + "${CMAKE_CURRENT_SOURCE_DIR}/../pic_test.h" + PIC_HEADER_CONTENT +) + +check_cxx_source_compiles( + " +${PIC_HEADER_CONTENT} +int main(int,char**) { return 0; }\n" + PIC_TRY_COMPILE_RESULT +) + +if (NOT PIC_TRY_COMPILE_RESULT) + message(SEND_ERROR "TRY_COMPILE with content requiring __PIC__ failed. ${OUTPUT}") +endif() diff --git a/Tests/PositionIndependentTargets/main.cpp b/Tests/PositionIndependentTargets/main.cpp new file mode 100644 index 000000000..e72cef7eb --- /dev/null +++ b/Tests/PositionIndependentTargets/main.cpp @@ -0,0 +1,2 @@ + +int main(int,char**) { return 0; } diff --git a/Tests/PositionIndependentTargets/pic_lib.cpp b/Tests/PositionIndependentTargets/pic_lib.cpp new file mode 100644 index 000000000..b8b25a33e --- /dev/null +++ b/Tests/PositionIndependentTargets/pic_lib.cpp @@ -0,0 +1,12 @@ + +#include "pic_test.h" + +class PIC_TEST_EXPORT Dummy +{ + int dummy(); +}; + +int Dummy::dummy() +{ + return 0; +} diff --git a/Tests/PositionIndependentTargets/pic_main.cpp b/Tests/PositionIndependentTargets/pic_main.cpp new file mode 100644 index 000000000..6a41a7a6b --- /dev/null +++ b/Tests/PositionIndependentTargets/pic_main.cpp @@ -0,0 +1,4 @@ + +#include "pic_test.h" + +int main(int,char**) { return 0; } diff --git a/Tests/PositionIndependentTargets/pic_test.h b/Tests/PositionIndependentTargets/pic_test.h new file mode 100644 index 000000000..3f64557e9 --- /dev/null +++ b/Tests/PositionIndependentTargets/pic_test.h @@ -0,0 +1,20 @@ + +#if defined(__ELF__) +# if !defined(__PIC__) +# error "The POSITION_INDEPENDENT_CODE property should cause __PIC__ to be defined on ELF platforms." +# endif +#endif + +#if defined(PIC_TEST_STATIC_BUILD) +# define PIC_TEST_EXPORT +#else +# if defined(_WIN32) || defined(WIN32) /* Win32 version */ +# ifdef PIC_TEST_BUILD_DLL +# define PIC_TEST_EXPORT __declspec(dllexport) +# else +# define PIC_TEST_EXPORT __declspec(dllimport) +# endif +# else +# define PIC_TEST_EXPORT +# endif +#endif diff --git a/Tests/PositionIndependentTargets/targets/CMakeLists.txt b/Tests/PositionIndependentTargets/targets/CMakeLists.txt new file mode 100644 index 000000000..4724c854a --- /dev/null +++ b/Tests/PositionIndependentTargets/targets/CMakeLists.txt @@ -0,0 +1,20 @@ + +add_executable(test_target_executable_properties "${CMAKE_CURRENT_SOURCE_DIR}/../pic_main.cpp") +set_target_properties(test_target_executable_properties + PROPERTIES + POSITION_INDEPENDENT_CODE True +) + +add_library(test_target_shared_library_properties SHARED "${CMAKE_CURRENT_SOURCE_DIR}/../pic_lib.cpp") +set_target_properties(test_target_shared_library_properties + PROPERTIES + POSITION_INDEPENDENT_CODE True + DEFINE_SYMBOL PIC_TEST_BUILD_DLL +) + +add_library(test_target_static_library_properties STATIC "${CMAKE_CURRENT_SOURCE_DIR}/../pic_lib.cpp") +set_target_properties(test_target_static_library_properties + PROPERTIES + POSITION_INDEPENDENT_CODE True + COMPILE_DEFINITIONS PIC_TEST_STATIC_BUILD +)