kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/CMakeCXXCompilerId.cpp.in

63 lines
1.7 KiB
C++
Raw Normal View History

STYLE: Added comment explaining choice of file extension.
2007-05-01 02:10:37 +04:00
/* This source file must have a .cpp extension so that all C++ compilers
recognize the extension without flags. Borland does not know .cxx for
example. */
ENH: Merging CompilerId implementation from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-bp and CMake-Modules-CompilerId-mp1 are included.
2007-04-28 17:35:01 +04:00
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#endif
Project: Generate the CXX compiler Id test from multiple files. This will allow sharing of the logic of the order to test compilers in and the preprocessor macros used to do that and to determine the version components.
2014-04-22 18:34:47 +04:00
@CMAKE_CXX_COMPILER_ID_CONTENT@
ENH: Unify design of CMakeCCompilerId.c, CMakeCXXCompilerId.cpp, and CMakePlatformId.h. BUG: Do not violate system-reserved symbol namespace _[A-Z].
2007-05-23 19:00:54 +04:00
ENH: Make compiler id detection more robust - Split INFO strings in source into multiple pieces to make sure assembly or other listings produced by the compiler are never matched by the regex - Store INFO strings via pointer instead of array to convince some compilers to store the string literally in the binary - This should help make it work for sdcc 2.8.0 RC1
2008-03-10 16:32:25 +03:00
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
Fix constness in compiler id detection Since commit 70c2dc8a (Make compiler id detection more robust, 2008-03-10) we store compiler identification strings in test binaries using the form char* info = "info"; Use the const-correct char const* info = "info"; form instead. This allows the C++ compiler identification to work with "-Werror -Wall" or equivalent flags if the compiler would warn about const-to-non-const conversion.
2010-12-29 23:35:15 +03:00
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
CMakeDetermineCompilerId: Add notion of "simulated" id/version Some compilers try to simulate other compilers as a drop-in replacement supporting all the same command-line options and predefined preprocessor macros. In such cases it will be useful to have CMake load the compiler information files for the simulated compiler instead of duplicating the information. Teach CMakeDetermineCompilerId to extract the simulated compiler id and version when the compiler id detection provides it.
2013-10-04 18:10:22 +04:00
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
ENH: Merging CompilerId implementation from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-bp and CMake-Modules-CompilerId-mp1 are included.
2007-04-28 17:35:01 +04:00
QNX: Introduce QCC compiler id for that QNX platform compiler. Introduce policy CMP0047 to control resetting the id for compatibility. De-duplicate content in the QNX platform file by including the GNU one. QNX is a form of GNU platform. Do not clear CMAKE_SHARED_LIBRARY_${lang}_FLAGS variables. They are populated again later by the Compiler/GNU.cmake file anyway. Modify the CMAKE_CXX_COMPILE_OBJECT variable only when the QCC compiler id is in use, and the language is CXX. Use the QNX recommended flag for QCC instead of the gcc compatible -x flag. Populate new module files to handle system includes and depfiles when using the QCC compiler. Remove code which unsets the system include and depfiles related variables. When a GNU driver is used instead of the QCC one, the appropriate flags will be used. These variables were previously cleared for lowest-common-denominator compatibility with both drivers.
2014-01-20 20:57:40 +04:00
#ifdef __QNXNTO__
QNX: Fix detection of QCC compiler id (#15349) In commit v3.1.0-rc1~113^2 (Use a more reliable regex for extracting binary INFO strings, 2014-09-03) the matching of INFO: strings was made more strict and no longer matches just "INFO:qnxnto". Use "INFO:qnxnto[]" instead to conform to the new pattern.
2015-01-14 18:28:59 +03:00
char const* qnxnto = "INFO" ":" "qnxnto[]";
QNX: Introduce QCC compiler id for that QNX platform compiler. Introduce policy CMP0047 to control resetting the id for compatibility. De-duplicate content in the QNX platform file by including the GNU one. QNX is a form of GNU platform. Do not clear CMAKE_SHARED_LIBRARY_${lang}_FLAGS variables. They are populated again later by the Compiler/GNU.cmake file anyway. Modify the CMAKE_CXX_COMPILE_OBJECT variable only when the QCC compiler id is in use, and the language is CXX. Use the QNX recommended flag for QCC instead of the gcc compatible -x flag. Populate new module files to handle system includes and depfiles when using the QCC compiler. Remove code which unsets the system include and depfiles related variables. When a GNU driver is used instead of the QCC one, the appropriate flags will be used. These variables were previously cleared for lowest-common-denominator compatibility with both drivers.
2014-01-20 20:57:40 +04:00
#endif
Cray: Add macro tests to detect the Cray compiler wrappers
2015-12-02 18:59:47 +03:00
#if defined(__CRAYXE) || defined(__CRAYXC)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
ENH: Improvied compiler identification robustness - Write a single source file into the compiler id directory - This avoid requiring the compiler to behave correctly with respect to include rules and the current working directory - Helps to identify cross-compiling toolchains with unusual default behavior
2008-02-25 17:23:14 +03:00
@CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT@
Require CMAKE_<LANG>_COMPILER to be found as a full path All generators now support detection of the full path to the compiler, so require it to be so. This will allow CMake<LANG>Information.cmake and other logic to assume the full path to the compiler tool is available. The Makefile generators already rejected CMAKE_<LANG>_COMPILER values that did not name an existing compiler. Extend this error message to all generators, make it occur as early as possible, and improve the message with advice about how to set the compiler. If the full path to the compiler is not known, finish enabling languages with a fatal error so configuration does not continue. For now, allow the RC language compiler to not be a full path. Later we will need to detect the full path to "rc" under the VS IDE. Add a RunCMake.CompilerNotFound test to cover failure cases. Fix the RunCMake.CompilerChange test EmptyCompiler case to work when configuration does not continue past enable_language.
2013-10-24 21:04:24 +04:00
@CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST@
ENH: Improve robustness of compiler INFO strings Compiler INFO strings built at preprocessing time encode information that must appear as a string literal in the resulting binary. We must make sure the strings appear in the final binary no matter what compiler and flags are used. The previous implementation worked in most places but failed with the GNU linker's --gc-sections option which managed to discard the string. Instead we make the program return value depend on an element of the string indexed by a runtime program parameter, which absolutely requires the string to be present.
2008-08-07 17:09:45 +04:00
Project: Determine default language dialect for the compiler. Use the __cplusplus and __STDC_VERSION__ macros to automatically determine the default dialect for the compiler while determining its id and version.
2015-09-15 20:42:26 +03:00
const char* info_language_dialect_default = "INFO" ":" "dialect_default["
#if __cplusplus >= 201402L
"14"
#elif __cplusplus >= 201103L
"11"
#else
"98"
#endif
"]";
ENH: Improve robustness of compiler INFO strings Compiler INFO strings built at preprocessing time encode information that must appear as a string literal in the resulting binary. We must make sure the strings appear in the final binary no matter what compiler and flags are used. The previous implementation worked in most places but failed with the GNU linker's --gc-sections option which managed to discard the string. Instead we make the program return value depend on an element of the string indexed by a runtime program parameter, which absolutely requires the string to be present.
2008-08-07 17:09:45 +04:00
/*--------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
Add framework to detect compiler version with its id (#12408) Teach CMakePlatformId.h to construct an "INFO:compiler_version[]" string literal from macros COMPILER_VERSION_(MAJOR|MINOR|PATCH|TWEAK) to be defined in CMake(C|CXX)CompilerId.(c|cpp) for each compiler. Provide conversion macros DEC() and HEX() to decode decimal or hex digits from integer values. Parse the version out of the compiler id binary along with the other INFO values already present. Store the result in variable CMAKE_<LANG>_COMPILER_VERSION in the format "major[.minor[.patch[.tweak]]]". Save the value persistently in CMake(C|CXX)Compiler.cmake in the build tree. Document the variable for internal use since we do not set it everywhere yet. Report the compiler version on the compiler id result line e.g. The C compiler identification is GNU 4.5.2 Report CMAKE_(C|CXX)_COMPILER_(ID|VERSION) in SystemInformation test.
2011-12-05 18:44:09 +04:00
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
CMakeDetermineCompilerId: Add notion of "simulated" id/version Some compilers try to simulate other compilers as a drop-in replacement supporting all the same command-line options and predefined preprocessor macros. In such cases it will be useful to have CMake load the compiler information files for the simulated compiler instead of duplicating the information. Teach CMakeDetermineCompilerId to extract the simulated compiler id and version when the compiler id detection provides it.
2013-10-04 18:10:22 +04:00
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
Cray: Add macro tests to detect the Cray compiler wrappers
2015-12-02 18:59:47 +03:00
#endif
#if defined(__CRAYXE) || defined(__CRAYXC)
require += info_cray[argc];
Add framework to detect compiler version with its id (#12408) Teach CMakePlatformId.h to construct an "INFO:compiler_version[]" string literal from macros COMPILER_VERSION_(MAJOR|MINOR|PATCH|TWEAK) to be defined in CMake(C|CXX)CompilerId.(c|cpp) for each compiler. Provide conversion macros DEC() and HEX() to decode decimal or hex digits from integer values. Parse the version out of the compiler id binary along with the other INFO values already present. Store the result in variable CMAKE_<LANG>_COMPILER_VERSION in the format "major[.minor[.patch[.tweak]]]". Save the value persistently in CMake(C|CXX)Compiler.cmake in the build tree. Document the variable for internal use since we do not set it everywhere yet. Report the compiler version on the compiler id result line e.g. The C compiler identification is GNU 4.5.2 Report CMAKE_(C|CXX)_COMPILER_(ID|VERSION) in SystemInformation test.
2011-12-05 18:44:09 +04:00
#endif
Make C and C++ default dialect detection robust to advanced optimizations In commit v3.4.0-rc1~71^2 (Project: Determine default language dialect for the compiler, 2015-09-15) we added an "INFO:..." string to the compiler id detection binary. The value can be optimized out of the compiler id binary unless we force it to be included by making the program behavior depend on it at runtime. Add references to the value as we do for the other info strings already. Gentoo-Issue: https://bugs.gentoo.org/show_bug.cgi?id=565744
2015-11-18 18:12:25 +03:00
require += info_language_dialect_default[argc];
ENH: Improve robustness of compiler INFO strings Compiler INFO strings built at preprocessing time encode information that must appear as a string literal in the resulting binary. We must make sure the strings appear in the final binary no matter what compiler and flags are used. The previous implementation worked in most places but failed with the GNU linker's --gc-sections option which managed to discard the string. Instead we make the program return value depend on an element of the string indexed by a runtime program parameter, which absolutely requires the string to be present.
2008-08-07 17:09:45 +04:00
(void)argv;
return require;
}