ShuriZma
/
visualboyadvance-m
mirror of https://github.com/visualboyadvance-m/visualboyadvance-m.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
visualboyadvance-m/cmake/UseGCCBinUtilsWrappers.cmake

104 lines
3.4 KiB
CMake
Raw Normal View History

add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
# UseGCCBinUtilsWrappers.cmake
#
# Use gcc binutils wrappers such as gcc-ar, this may be necessary for LTO.
#
# To use:
#
# put a copy into your <project_root>/CMakeScripts/
#
# In your main CMakeLists.txt add the command:
#
# INCLUDE(UseGCCBinUtilsWrappers)
#
# BSD 2-Clause License
#
# Copyright (c) 2016, Rafael Kitover
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# only do this when compiling with gcc/g++
IF(NOT (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUC))
RETURN()
ENDIF()
# first try appending -util to basename of compiler
STRING(REGEX MATCH "\\.(exe|EXE)$" GCC_EXE_SUFFIX ${CMAKE_C_COMPILER})
STRING(REGEX REPLACE "\\.(exe|EXE)$" "" GCC_BASENAME ${CMAKE_C_COMPILER})
SET(GCC_AR "${GCC_BASENAME}-ar${GCC_EXE_SUFFIX}")
SET(GCC_NM "${GCC_BASENAME}-nm${GCC_EXE_SUFFIX}")
SET(GCC_RANLIB "${GCC_BASENAME}-ranlib${GCC_EXE_SUFFIX}")
# if that does not work, try looking for gcc-util in the compiler directory,
# and failing that in the PATH
GET_FILENAME_COMPONENT(GCC_DIRNAME ${CMAKE_C_COMPILER} DIRECTORY)
IF(NOT EXISTS ${GCC_AR})
UNSET(GCC_AR)
FIND_PROGRAM(GCC_AR NAMES gcc-ar gcc-ar.exe GCC-AR.EXE HINTS ${GCC_DIRNAME})
ENDIF()
IF(NOT EXISTS ${GCC_NM})
UNSET(GCC_NM)
FIND_PROGRAM(GCC_NM NAMES gcc-nm gcc-nm.exe GCC-NM.EXE HINTS ${GCC_DIRNAME})
ENDIF()
IF(NOT EXISTS ${GCC_RANLIB})
UNSET(GCC_RANLIB)
FIND_PROGRAM(GCC_RANLIB NAMES gcc-ranlib gcc-ranlib.exe GCC-RANLIB.EXE HINTS ${GCC_DIRNAME})
ENDIF()
work around gcc lto wrappers bug with gcc 7.x gcc lto wrapper commands such as `gcc-ar` will segfault with some versions of gcc 7.x when called via an absolute path, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80717 Generalize the mechanism for compiling a small C program on the host (currently used for bin2c for Wx resources) and use it to wrap the gcc wrappers in a little executable that prepends their dirname to PATH and runs them with `execvp()`. Make LTO default to ON again, except on win32 with gcc < 7, because those toolchains produce broken binaries with LTO enabled. Also add `-ffat-lto-objects` to compiler flags for gcc when LTO is enabled, this will increase the chances that the LTO build will succeed even if there are issues with the binutils wrappers. Clang does not support this.
2017-09-17 02:47:39 +00:00
INCLUDE(PathRun)
add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
IF(EXISTS ${GCC_AR})
work around gcc lto wrappers bug with gcc 7.x gcc lto wrapper commands such as `gcc-ar` will segfault with some versions of gcc 7.x when called via an absolute path, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80717 Generalize the mechanism for compiling a small C program on the host (currently used for bin2c for Wx resources) and use it to wrap the gcc wrappers in a little executable that prepends their dirname to PATH and runs them with `execvp()`. Make LTO default to ON again, except on win32 with gcc < 7, because those toolchains produce broken binaries with LTO enabled. Also add `-ffat-lto-objects` to compiler flags for gcc when LTO is enabled, this will increase the chances that the LTO build will succeed even if there are issues with the binutils wrappers. Clang does not support this.
2017-09-17 02:47:39 +00:00
MESSAGE("-- Found gcc-ar: ${GCC_AR}")
SET(target "${CMAKE_BINARY_DIR}/gcc-ar-wrap")
MAKE_PATH_RUN_WRAPPER("${GCC_AR}" "${target}")
SET(CMAKE_AR "${target}")
add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
ENDIF()
IF(EXISTS ${GCC_NM})
work around gcc lto wrappers bug with gcc 7.x gcc lto wrapper commands such as `gcc-ar` will segfault with some versions of gcc 7.x when called via an absolute path, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80717 Generalize the mechanism for compiling a small C program on the host (currently used for bin2c for Wx resources) and use it to wrap the gcc wrappers in a little executable that prepends their dirname to PATH and runs them with `execvp()`. Make LTO default to ON again, except on win32 with gcc < 7, because those toolchains produce broken binaries with LTO enabled. Also add `-ffat-lto-objects` to compiler flags for gcc when LTO is enabled, this will increase the chances that the LTO build will succeed even if there are issues with the binutils wrappers. Clang does not support this.
2017-09-17 02:47:39 +00:00
MESSAGE("-- Found gcc-nm: ${GCC_NM}")
SET(target "${CMAKE_BINARY_DIR}/gcc-nm-wrap")
MAKE_PATH_RUN_WRAPPER("${GCC_NM}" "${target}")
SET(CMAKE_NM "${target}")
add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
ENDIF()
IF(EXISTS ${GCC_RANLIB})
work around gcc lto wrappers bug with gcc 7.x gcc lto wrapper commands such as `gcc-ar` will segfault with some versions of gcc 7.x when called via an absolute path, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80717 Generalize the mechanism for compiling a small C program on the host (currently used for bin2c for Wx resources) and use it to wrap the gcc wrappers in a little executable that prepends their dirname to PATH and runs them with `execvp()`. Make LTO default to ON again, except on win32 with gcc < 7, because those toolchains produce broken binaries with LTO enabled. Also add `-ffat-lto-objects` to compiler flags for gcc when LTO is enabled, this will increase the chances that the LTO build will succeed even if there are issues with the binutils wrappers. Clang does not support this.
2017-09-17 02:47:39 +00:00
MESSAGE("-- Found gcc-ranlib: ${GCC_RANLIB}")
SET(target "${CMAKE_BINARY_DIR}/gcc-ranlib-wrap")
MAKE_PATH_RUN_WRAPPER("${GCC_RANLIB}" "${target}")
SET(CMAKE_RANLIB "${target}")
add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
ENDIF()
work around gcc lto wrappers bug with gcc 7.x gcc lto wrapper commands such as `gcc-ar` will segfault with some versions of gcc 7.x when called via an absolute path, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80717 Generalize the mechanism for compiling a small C program on the host (currently used for bin2c for Wx resources) and use it to wrap the gcc wrappers in a little executable that prepends their dirname to PATH and runs them with `execvp()`. Make LTO default to ON again, except on win32 with gcc < 7, because those toolchains produce broken binaries with LTO enabled. Also add `-ffat-lto-objects` to compiler flags for gcc when LTO is enabled, this will increase the chances that the LTO build will succeed even if there are issues with the binutils wrappers. Clang does not support this.
2017-09-17 02:47:39 +00:00
FOREACH(VAR "GCC_AR" "GCC_NM" "GCC_RANLIB" "GCC_DIRNAME" "GCC_BASENAME" "GCC_EXE_SUFFIX" "target")
add LTO support, fix libssp link, add -ggdb3 -Og Add support for Link Time Optimization (LTO) on gcc and Clang. Link libssp only when it is on the system, some toolchains like Ubuntu's do not require explicitly linking to libssp. On Win32 try to link it statically. In debug builds with GCC, use -ggdb3 -Og, otherwise use -g . Two new cmake modules were written for this: * FindSSP.cmake -- this is for finding libssp on the system. * UseGCCBinUtilsWrappers.cmake -- this is for using gcc binutils wrappers such as gcc-ar, which is required for gcc LTO to work. These will be distributed separately as well.
2016-11-21 20:37:21 +00:00
UNSET(${VAR})
ENDFOREACH()