|
|
@@ -0,0 +1,611 @@
|
|
|
+#
|
|
|
+# Copyright (c) 2016-2017 Yao Wei Tjong. All rights reserved.
|
|
|
+#
|
|
|
+# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
+# of this software and associated documentation files (the "Software"), to deal
|
|
|
+# in the Software without restriction, including without limitation the rights
|
|
|
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
+# copies of the Software, and to permit persons to whom the Software is
|
|
|
+# furnished to do so, subject to the following conditions:
|
|
|
+#
|
|
|
+# The above copyright notice and this permission notice shall be included in
|
|
|
+# all copies or substantial portions of the Software.
|
|
|
+#
|
|
|
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
+# THE SOFTWARE.
|
|
|
+#
|
|
|
+
|
|
|
+# Modified by Yao Wei Tjong for Urho3D
|
|
|
+
|
|
|
+#
|
|
|
+# This CMake toolchain file is designed to work with both cmake-gui and cmake CLI.
|
|
|
+# It is inspired from https://github.com/taka-no-me/android-cmake/android.toolchain.cmake,
|
|
|
+# most of its options are kept for compatibility, however, the possible values for each option are not identical.
|
|
|
+#
|
|
|
+# Options:
|
|
|
+# ANDROID_NDK - path to the NDK root.
|
|
|
+# Can be set as environment variable.
|
|
|
+# NOTE: This option cannot be changed after the initial configuration/generation.
|
|
|
+#
|
|
|
+# ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-clang - the name of compiler toolchain to be used.
|
|
|
+# The possible values are derived from the prebuilt compiler toolchains in the Android NDK.
|
|
|
+# NOTE: This option cannot be changed after the initial configuration/generation.
|
|
|
+#
|
|
|
+# ANDROID_ABI=armeabi-v7a - specifies the target Application Binary Interface (ABI).
|
|
|
+# This option nearly matches to the APP_ABI variable used by ndk-build tool from Android NDK.
|
|
|
+#
|
|
|
+# Possible targets are:
|
|
|
+# 1) For arm arch:
|
|
|
+# armeabi-v7a - ARMv7 based devices with hardware FPU instructions but software floating-point calling convention (softfp).
|
|
|
+# armeabi-v6 - ARMv6 based devices with hardware FPU instructions but software floating-point calling convention (softfp).
|
|
|
+# armeabi - ARMv5TE based CPU with software floating point operations (soft).
|
|
|
+#
|
|
|
+# These ABI options can be combined with one of the below modifiers to specify which hardware FPU to use:
|
|
|
+# "with neon-vfpv4" - Use NEON SIMD and VFPv4.
|
|
|
+# "with neon" - Use NEON SIMD and VFPv3.
|
|
|
+# "with vfpv4" - Use VFPv4.
|
|
|
+# "with vfpv3" - Use VFPv3 (32 registers).
|
|
|
+# "with vfpv3-d16" - Use VFPv3 (16 registers). This is the default for ARMv7.
|
|
|
+# "with vfp" - Use VFPv2. This is the default and the only possible combination for ARMv6.
|
|
|
+#
|
|
|
+# 2) For aarch64 arch:
|
|
|
+# arm64-v8a - ARMv8 AArch64 instruction set.
|
|
|
+#
|
|
|
+# 3) For i686 arch:
|
|
|
+# x86 - IA-32 instruction set.
|
|
|
+#
|
|
|
+# 4) For x86_64 arch:
|
|
|
+# x86_64 - Intel64 instruction set.
|
|
|
+#
|
|
|
+# 5) For mipsel arch:
|
|
|
+# mips - MIPS32 instruction set.
|
|
|
+#
|
|
|
+# 6) For mips64el arch:
|
|
|
+# mips64 - MIPS64 instruction set.
|
|
|
+#
|
|
|
+# ANDROID_NATIVE_API_LEVEL=android-9 - level of Android API compile for.
|
|
|
+# The default level is android-21 when targeting any of the 64-bit ABIs.
|
|
|
+# NOTE: The level must not be larger than android:minSdkVersion in AndroidManifest.xml.
|
|
|
+#
|
|
|
+# ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions instead of Thumb.
|
|
|
+# This option is only available for arm arch.
|
|
|
+#
|
|
|
+# ANDROID_STACK_PROTECTION=OFF - set ON to force the addition of a stack canary that checks for stack smashing.
|
|
|
+# When it is ON the generated binary may be larger in size and slower in performance.
|
|
|
+# Unlike ndk-build, it is defaulted to OFF.
|
|
|
+#
|
|
|
+# ANDROID_NO_UNDEFINED=ON - set ON to show all undefined symbols as linker errors even if they are not used.
|
|
|
+#
|
|
|
+# ANDROID_NOEXECSTACK=ON - set ON to enforce the NX (no execute) security feature in the generated machine code.
|
|
|
+#
|
|
|
+# ANDROID_RELRO=ON - set ON to mark certain regions of the resulting executable or shared library as being read-only.
|
|
|
+#
|
|
|
+# ANDROID_FATAL_WARNINGS=ON - set ON to treat all linker warnings as errors.
|
|
|
+#
|
|
|
+# ANDROID_FORMAT_SECURITY=ON - set ON to provide compiler protection against format string vulnerabilities.
|
|
|
+#
|
|
|
+# ANDROID_FUNCTION_LEVEL_LINKING=ON - set ON to split data/function sections and garbage collect unused sections at link time.
|
|
|
+# This option may be turned off to avoid potential debugging problems in Debug build configuration.
|
|
|
+#
|
|
|
+# ANDROID_STL=system - specify the C++ STL runtime to use.
|
|
|
+# When ANDROID_STL_FORCE_FEATURES is ON then it auto-configures the RTTI and exceptions settings to ON for any runtime chosen,
|
|
|
+# except for default system runtime.
|
|
|
+# NOTE: Use shared runtime when your project contains multiple shared libraries or executables.
|
|
|
+# Otherwise, the build system does not define certain global uniquely, which can result in unpredictable runtime behavior.
|
|
|
+# This behavior may include crashes and failure to properly catch exceptions.
|
|
|
+#
|
|
|
+# Possible values are:
|
|
|
+# system -> Use the minimal system C++ runtime library. Implies -fno-rtti -fno-exceptions.
|
|
|
+# gabi++_static -> Use the GAbi++ runtime as a static library.
|
|
|
+# gabi++_shared -> Use the GAbi++ runtime as a shared library.
|
|
|
+# stlport_static -> Use the STLport runtime as a static library. STLport is licensed under BSD-like license.
|
|
|
+# stlport_shared -> Use the STLport runtime as a shared library.
|
|
|
+# gnustl_static -> Use the GNU libstdc++ as a static library. GNU libstdc++ is licensed under GPLv3 + linking exception.
|
|
|
+# gnustl_shared -> Use the GNU libstdc++ as a shared library.
|
|
|
+# c++_static -> Use the LLVM libc++ runtime as a static library. LLVM libc++ is licensed under BSD-Like and MIT license.
|
|
|
+# c++_shared -> Use the LLVM libc++ runtime as a shared library.
|
|
|
+#
|
|
|
+# ANDROID_STL_FORCE_FEATURES=ON - automatically configure rtti and exceptions settings based on the chosen C++ STL runtime.
|
|
|
+# If disabled, then the user is responsible for setting ANDROID_RTTI and ANDROID_EXCEPTIONS options manually.
|
|
|
+#
|
|
|
+# ANDROID_RTTI=ON - set ON to enable RTTI.
|
|
|
+# This option is only available when ANDROID_STL_FORCE_FEATURES is disabled.
|
|
|
+#
|
|
|
+# ANDROID_EXCEPTIONS=ON - set ON to enable C++ exceptions.
|
|
|
+# This option is only available when ANDROID_STL_FORCE_FEATURES is disabled.
|
|
|
+#
|
|
|
+
|
|
|
+cmake_minimum_required (VERSION 3.2.3)
|
|
|
+mark_as_advanced (CMAKE_TOOLCHAIN_FILE)
|
|
|
+set (CMAKE_SYSTEM_NAME Android)
|
|
|
+set (CMAKE_SYSTEM_VERSION 1)
|
|
|
+set (CMAKE_POSITION_INDEPENDENT_CODE 1)
|
|
|
+set (ANDROID 1)
|
|
|
+
|
|
|
+# Prevent critical variables from changing after the initial configuration
|
|
|
+if (CMAKE_CROSSCOMPILING)
|
|
|
+ set (SAVED_ANDROID_NDK ${ANDROID_NDK} CACHE INTERNAL "Initial value for ANDROID_NDK")
|
|
|
+ set (SAVED_ANDROID_TOOLCHAIN_NAME ${ANDROID_TOOLCHAIN_NAME} CACHE INTERNAL "Initial value for ANDROID_TOOLCHAIN_NAME")
|
|
|
+ # Urho3D - save the initial values of CC and CXX environment variables
|
|
|
+ set (SAVED_CC $ENV{CC} CACHE INTERNAL "Initial value for CC")
|
|
|
+ set (SAVED_CXX $ENV{CXX} CACHE INTERNAL "Initial value for CXX")
|
|
|
+ return ()
|
|
|
+elseif ((SAVED_ANDROID_NDK AND NOT SAVED_ANDROID_NDK STREQUAL ANDROID_NDK) OR (SAVED_ANDROID_TOOLCHAIN_NAME AND NOT SAVED_ANDROID_TOOLCHAIN_NAME STREQUAL ANDROID_TOOLCHAIN_NAME))
|
|
|
+ set (ANDROID_NDK ${SAVED_ANDROID_NDK} CACHE PATH "Path to Android NDK (Android platform only)" FORCE)
|
|
|
+ set (ANDROID_TOOLCHAIN_NAME ${SAVED_ANDROID_TOOLCHAIN_NAME} CACHE STRING "Specify the name of compiler toolchain (Android platform only), possible values depends on installed Android NDK, default to Clang compiler toolchain" FORCE)
|
|
|
+ message (FATAL_ERROR "ANDROID_NDK and ANDROID_TOOLCHAIN_NAME cannot be changed after the initial configuration/generation. "
|
|
|
+ "Auto reverting to its initial value. If you wish to change it then the build tree would have to be regenerated from scratch.")
|
|
|
+endif ()
|
|
|
+
|
|
|
+# Workaround try_compile() limitation where it cannot see cache variables and it is a waste of time to reinit everything all over
|
|
|
+get_property (IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE)
|
|
|
+if (NOT IN_TRY_COMPILE)
|
|
|
+ # Android NDK paths
|
|
|
+ if (NOT SAVED_ANDROID_NDK)
|
|
|
+ if (NOT ANDROID_NDK AND DEFINED ENV{ANDROID_NDK})
|
|
|
+ file (TO_CMAKE_PATH $ENV{ANDROID_NDK} ANDROID_NDK)
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_NDK ${ANDROID_NDK} CACHE PATH "Path to Android NDK (Android platform only)")
|
|
|
+ if (NOT EXISTS ${ANDROID_NDK})
|
|
|
+ message (FATAL_ERROR "Could not find Android NDK. "
|
|
|
+ "Use ANDROID_NDK environment variable or build option to specify the location of Android NDK.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ if (NOT ANDROID_NDK_VERSION)
|
|
|
+ if (EXISTS ${ANDROID_NDK}/source.properties)
|
|
|
+ file (STRINGS ${ANDROID_NDK}/source.properties LINE LIMIT_COUNT 1 REGEX [0-9]+\\.[0-9]+\\.[0-9]+)
|
|
|
+ endif ()
|
|
|
+ if (LINE MATCHES "([0-9]+\\.[0-9]+\\.[0-9]+)")
|
|
|
+ set (ANDROID_NDK_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL "Android NDK version")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_NDK_VERSION LESS 12)
|
|
|
+ unset (ANDROID_NDK_VERSION CACHE)
|
|
|
+ message (FATAL_ERROR "Unsupported Android NDK version. This toolchain file only supports Android NDK r12 onward.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_NDK_TOOLCHAINS_CONFIG_PATH ${ANDROID_NDK}/build/core/toolchains)
|
|
|
+ set (ANDROID_NDK_TOOLCHAINS_PATH ${ANDROID_NDK}/toolchains)
|
|
|
+ if (NOT ANDROID_NDK_HOST_SYSTEM_NAME)
|
|
|
+ file (GLOB ANDROID_NDK_HOST_SYSTEM_NAME RELATIVE ${ANDROID_NDK_TOOLCHAINS_PATH}/llvm/prebuilt ${ANDROID_NDK_TOOLCHAINS_PATH}/llvm/prebuilt/*)
|
|
|
+ set (ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME} CACHE INTERNAL "Android NDK host system name")
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_NDK_TOOLCHAINS_SUBPATH /prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME})
|
|
|
+
|
|
|
+ # Android compiler toolchains
|
|
|
+ if (NOT SAVED_ANDROID_TOOLCHAIN_NAME)
|
|
|
+ set (ANDROID_DEFAULT_TOOLCHAIN_NAME arm-linux-androideabi-clang)
|
|
|
+ set (ANDROID_TOOLCHAIN_NAME ${ANDROID_DEFAULT_TOOLCHAIN_NAME} CACHE STRING "Specify the name of compiler toolchain (Android platform only), default to ${ANDROID_DEFAULT_TOOLCHAIN_NAME}")
|
|
|
+ file (GLOB ANDROID_SUPPORTED_TOOLCHAINS RELATIVE ${ANDROID_NDK_TOOLCHAINS_CONFIG_PATH} ${ANDROID_NDK_TOOLCHAINS_CONFIG_PATH}/*)
|
|
|
+ list (SORT ANDROID_SUPPORTED_TOOLCHAINS)
|
|
|
+ set_property (CACHE ANDROID_TOOLCHAIN_NAME PROPERTY STRINGS ${ANDROID_SUPPORTED_TOOLCHAINS})
|
|
|
+ list (FIND ANDROID_SUPPORTED_TOOLCHAINS "${ANDROID_TOOLCHAIN_NAME}" FOUND_INDEX) # Stringify as the actual variable may be empty
|
|
|
+ if (FOUND_INDEX EQUAL -1)
|
|
|
+ string (REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_TOOLCHAINS "\"${ANDROID_SUPPORTED_TOOLCHAINS}\"")
|
|
|
+ message (FATAL_ERROR "Unrecognized '${ANDROID_TOOLCHAIN_NAME}' specified in the ANDROID_TOOLCHAIN_NAME option, "
|
|
|
+ "supported values are: ${PRINTABLE_ANDROID_SUPPORTED_TOOLCHAINS}.")
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_TOOLCHAIN_ROOT ${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_TOOLCHAIN_NAME}${ANDROID_NDK_TOOLCHAINS_SUBPATH})
|
|
|
+ if (ANDROID_TOOLCHAIN_NAME MATCHES "-clang.*$")
|
|
|
+ set (ANDROID_CLANG_TOOLCHAIN_ROOT ${ANDROID_NDK_TOOLCHAINS_PATH}/llvm${ANDROID_NDK_TOOLCHAINS_SUBPATH} CACHE INTERNAL "Clang toolchain root if using Clang")
|
|
|
+ set (CLANG CLANG_ CACHE INTERNAL "Non empty if using Clang")
|
|
|
+ # Check if it still depends on GCC toolchain for assembler and linker support (assume 4.9 is the last deprecated GCC version supported by Android NDK)
|
|
|
+ file (STRINGS ${ANDROID_NDK_TOOLCHAINS_CONFIG_PATH}/${ANDROID_TOOLCHAIN_NAME}/setup.mk ANDROID_ROOT_${ANDROID_TOOLCHAIN_NAME} REGEX ^TOOLCHAIN_ROOT.*-4.9)
|
|
|
+ if (ANDROID_ROOT_${ANDROID_TOOLCHAIN_NAME})
|
|
|
+ string (REGEX REPLACE -clang.*$ -4.9 GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}")
|
|
|
+ set (ANDROID_TOOLCHAIN_ROOT ${ANDROID_NDK_TOOLCHAINS_PATH}/${GCC_TOOLCHAIN_NAME}${ANDROID_NDK_TOOLCHAINS_SUBPATH})
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_TOOLCHAIN_ROOT ${ANDROID_TOOLCHAIN_ROOT} CACHE INTERNAL "GCC toolchain root")
|
|
|
+ endif ()
|
|
|
+ string (REGEX REPLACE -[^-]+$ "" ANDROID_TOOLCHAIN_MACHINE_NAME "${ANDROID_TOOLCHAIN_NAME}")
|
|
|
+ string (REGEX REPLACE -.*$|el "" MACHINE_ARCH "${ANDROID_TOOLCHAIN_MACHINE_NAME}")
|
|
|
+ if (ANDROID_TOOLCHAIN_MACHINE_NAME MATCHES x86)
|
|
|
+ string (REGEX REPLACE ^x86- i686- ANDROID_TOOLCHAIN_MACHINE_NAME "${ANDROID_TOOLCHAIN_MACHINE_NAME}-linux-android")
|
|
|
+ endif ()
|
|
|
+
|
|
|
+ # Android ABIs
|
|
|
+ if (NOT ANDROID_ABI OR NOT ANDROID_ABI_SAVED STREQUAL ANDROID_ABI)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_arm armeabi-v7a armeabi-v6 armeabi)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_aarch64 arm64-v8a)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_x86 x86)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_x86_64 x86_64)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_mips mips)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS_mips64 mips64)
|
|
|
+ set (ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${MACHINE_ARCH}})
|
|
|
+ list (GET ANDROID_SUPPORTED_ABIS 0 DEFAULT_ANDROID_ABI)
|
|
|
+ set (ANDROID_ABI ${DEFAULT_ANDROID_ABI} CACHE STRING "Specify target ABI (Android platform only), possible values depends on the target arch of the chosen Android compiler toolchain, default to first ABI of each target arch")
|
|
|
+ set_property (CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS})
|
|
|
+ if (ANDROID_ABI MATCHES with)
|
|
|
+ string (REGEX REPLACE ".+with (.+)" \\1 ANDROID_ABI_MODIFIER "${ANDROID_ABI}")
|
|
|
+ if (MACHINE_ARCH STREQUAL arm)
|
|
|
+ set (ANDROID_SUPPORTED_ARM_ABI_MODIFIERS neon-vfpv4 neon vfpv4 vfpv3 vfpv3-d16 vfp)
|
|
|
+ list (FIND ANDROID_SUPPORTED_ARM_ABI_MODIFIERS "${ANDROID_ABI_MODIFIER}" FOUND_INDEX) # Stringify as the variable may be empty
|
|
|
+ if (FOUND_INDEX EQUAL -1)
|
|
|
+ string (REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ARM_ABI_MODIFIERS "\"${ANDROID_SUPPORTED_ARM_ABI_MODIFIERS}\"")
|
|
|
+ message (FATAL_ERROR "Unrecognized '${ANDROID_ABI_MODIFIER}' specified in the ANDROID_ABI option, "
|
|
|
+ "supported values are: ${PRINTABLE_ANDROID_SUPPORTED_ARM_ABI_MODIFIERS}.")
|
|
|
+ endif ()
|
|
|
+ else ()
|
|
|
+ message (FATAL_ERROR "Unrecognized '${ANDROID_ABI_MODIFIER}' specified in the ANDROID_ABI option, "
|
|
|
+ "the chosen Android ABI does not support any modifiers.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ string (REGEX REPLACE with.+ "" ANDROID_ABI_BASE "${ANDROID_ABI}")
|
|
|
+ list (FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI_BASE}" FOUND_INDEX) # Stringify as the variable may be empty
|
|
|
+ if (FOUND_INDEX EQUAL -1)
|
|
|
+ string (REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ABIS "\"${ANDROID_SUPPORTED_ABIS}\"")
|
|
|
+ message (FATAL_ERROR "Unrecognized '${ANDROID_ABI}' specified in the ANDROID_ABI option, "
|
|
|
+ "supported values are: ${PRINTABLE_ANDROID_SUPPORTED_ABIS}.")
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_ABI_SAVED ${ANDROID_ABI} CACHE INTERNAL "Last saved value for ANDROID_ABI")
|
|
|
+ # Invalidate internal caches that depend on ANDROID_ABI, if any
|
|
|
+ unset (ANDROID_STL_SAVED CACHE) # This should cause ANDROID_STL option to be revalidated
|
|
|
+ if (CLANG)
|
|
|
+ set (INVALIDATE_CCT 1)
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ # First, derive variable values based on chosen compiler toolchain
|
|
|
+ set (ANDROID_NDK_ABI_NAME ${MACHINE_ARCH})
|
|
|
+ set (ANDROID_ARCH_NAME ${MACHINE_ARCH})
|
|
|
+ set (CMAKE_SYSTEM_PROCESSOR ${MACHINE_ARCH})
|
|
|
+ string (REGEX REPLACE "^([^-]+).*$" \\1-none-linux-android ANDROID_LLVM_TRIPLE "${ANDROID_TOOLCHAIN_MACHINE_NAME}")
|
|
|
+ # Then, handle exceptional cases based on chosen ABI
|
|
|
+ if (ANDROID_ABI MATCHES armeabi-v7a)
|
|
|
+ if (NOT ANDROID_ABI MATCHES with)
|
|
|
+ set (ANDROID_ABI "armeabi-v7a with vfpv3-d16") # This is the default case for armeabi-v7a
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_NDK_ABI_NAME armeabi-v7a)
|
|
|
+ set (CMAKE_SYSTEM_PROCESSOR armv7-a)
|
|
|
+ set (ANDROID_LLVM_TRIPLE armv7-none-linux-androideabi)
|
|
|
+ elseif (ANDROID_ABI MATCHES armeabi)
|
|
|
+ set (ANDROID_NDK_ABI_NAME armeabi)
|
|
|
+ if (ANDROID_ABI MATCHES -v6)
|
|
|
+ set (ANDROID_ABI "armeabi-v6 with vfp") # This is the default case for armeabi-v6
|
|
|
+ set (CMAKE_SYSTEM_PROCESSOR armv6)
|
|
|
+ else ()
|
|
|
+ set (CMAKE_SYSTEM_PROCESSOR armv5te)
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_LLVM_TRIPLE armv5te-none-linux-androideabi)
|
|
|
+ elseif (ANDROID_ABI STREQUAL arm64-v8a)
|
|
|
+ set (ANDROID_NDK_ABI_NAME arm64-v8a)
|
|
|
+ set (ANDROID_ARCH_NAME arm64)
|
|
|
+ elseif (ANDROID_ABI STREQUAL x86)
|
|
|
+ set (CMAKE_SYSTEM_PROCESSOR i686)
|
|
|
+ endif ()
|
|
|
+ include (CMakeDependentOption)
|
|
|
+ cmake_dependent_option (ANDROID_FORCE_ARM_BUILD "Use 32-bit ARM instructions instead of Thumb" FALSE "ANDROID_ARCH_NAME STREQUAL arm" FALSE)
|
|
|
+ # Urho3D - comment out as Urho manages the runtime and library output directories in its own module
|
|
|
+ #set (CMAKE_RUNTIME_OUTPUT_DIRECTORY {CMAKE_BINARY_DIR}/bin)
|
|
|
+ #set (CMAKE_LIBRARY_OUTPUT_DIRECTORY {CMAKE_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME})
|
|
|
+
|
|
|
+ # Android API levels
|
|
|
+ if (NOT ANDROID_NATIVE_API_LEVEL OR NOT ANDROID_NATIVE_API_LEVEL_SAVED STREQUAL ANDROID_NATIVE_API_LEVEL)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_arm 9)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_arm64 21)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_x86 9)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_x86_64 21)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_mips 9)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL_mips64 21)
|
|
|
+ set (ANDROID_DEFAULT_NDK_API_LEVEL ${ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME}})
|
|
|
+ set (ANDROID_NATIVE_API_LEVEL android-${ANDROID_DEFAULT_NDK_API_LEVEL} CACHE STRING "Specify target API level (Android platform only), default to 'android-9' on 32-bit ABIs, default to 'android-21' on 64-bit ABIs")
|
|
|
+ if (NOT SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME})
|
|
|
+ if (NOT SUPPORTED_NATIVE_API_LEVELS)
|
|
|
+ file (GLOB SUPPORTED_NATIVE_API_LEVELS RELATIVE ${ANDROID_NDK}/platforms ${ANDROID_NDK}/platforms/android-*)
|
|
|
+ string (REPLACE android- "" SUPPORTED_NATIVE_API_LEVELS "${SUPPORTED_NATIVE_API_LEVELS}")
|
|
|
+ set (SUPPORTED_NATIVE_API_LEVELS ${SUPPORTED_NATIVE_API_LEVELS} CACHE INTERNAL "Supported Android native API levels")
|
|
|
+ endif ()
|
|
|
+ set (SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} ${SUPPORTED_NATIVE_API_LEVELS})
|
|
|
+ foreach (API_LEVEL ${SUPPORTED_NATIVE_API_LEVELS})
|
|
|
+ if (API_LEVEL LESS ANDROID_DEFAULT_NDK_API_LEVEL OR API_LEVEL LESS 10)
|
|
|
+ list (REMOVE_ITEM SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} ${API_LEVEL})
|
|
|
+ endif ()
|
|
|
+ if (NOT API_LEVEL LESS ANDROID_DEFAULT_NDK_API_LEVEL AND API_LEVEL LESS 10)
|
|
|
+ list (APPEND SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} 0${API_LEVEL}) # Add 0 padding for sorting
|
|
|
+ endif ()
|
|
|
+ endforeach ()
|
|
|
+ list (SORT SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME})
|
|
|
+ string (REGEX REPLACE ";0*" ";android-" SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} ";${SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME}}")
|
|
|
+ string (REGEX REPLACE "^;" "" SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} "${SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME}}")
|
|
|
+ set (SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} ${SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME}} CACHE INTERNAL "Supported Android native API levels for arch ${ANDROID_ARCH_NAME}")
|
|
|
+ endif ()
|
|
|
+ set_property (CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME}})
|
|
|
+ list (FIND SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME} "${ANDROID_NATIVE_API_LEVEL}" FOUND_INDEX) # Stringify as the actual variable may be empty
|
|
|
+ if (FOUND_INDEX EQUAL -1)
|
|
|
+ string (REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_NATIVE_API_LEVELS "\"${SUPPORTED_NATIVE_API_LEVELS_${ANDROID_ARCH_NAME}}\"")
|
|
|
+ message (FATAL_ERROR "Unsupported '${ANDROID_NATIVE_API_LEVEL}' specified in the ANDROID_NATIVE_API_LEVEL option, "
|
|
|
+ "supported values are: ${PRINTABLE_ANDROID_SUPPORTED_NATIVE_API_LEVELS}.")
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_NATIVE_API_LEVEL_SAVED ${ANDROID_NATIVE_API_LEVEL} CACHE INTERNAL "Last saved value for ANDROID_NATIVE_API_LEVEL")
|
|
|
+ endif ()
|
|
|
+ # Warn if the chosen level is larger than android:minSdkVersion, this check can only done in CMake rerun (after the build tree has been generated)
|
|
|
+ string (REPLACE android- "" APP_PLATFORM_LEVEL "${ANDROID_NATIVE_API_LEVEL}")
|
|
|
+ if (EXISTS ${CMAKE_BINARY_DIR}/AndroidManifest.xml)
|
|
|
+ file (STRINGS ${CMAKE_BINARY_DIR}/AndroidManifest.xml LINE LIMIT_COUNT 1 REGEX android:minSdkVersion=)
|
|
|
+ if (LINE MATCHES "android:minSdkVersion=\"([^\"]+)\"")
|
|
|
+ set (APP_MIN_PLATFORM_LEVEL ${CMAKE_MATCH_1})
|
|
|
+ if (APP_PLATFORM_LEVEL GREATER APP_MIN_PLATFORM_LEVEL)
|
|
|
+ message (WARNING "ANDROID_NATIVE_API_LEVEL (${ANDROID_NATIVE_API_LEVEL}) is larger than android:minSdkVersion (${APP_MIN_PLATFORM_LEVEL}) in AndroidManifest.xml.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+
|
|
|
+ # System root
|
|
|
+ set (CMAKE_SYSROOT ${ANDROID_NDK}/platforms/${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME})
|
|
|
+
|
|
|
+ # C++ STL runtimes
|
|
|
+ option (ANDROID_STL_FORCE_FEATURES "Automatically configure rtti and exceptions support based on the chosen C++ STL runtime" TRUE)
|
|
|
+ # Urho3D - always use RTTI due to dynamic cast usage in the codebase
|
|
|
+ #cmake_dependent_option (ANDROID_RTTI "Set ON to enable RTTI" TRUE "NOT ANDROID_STL_FORCE_FEATURES" TRUE)
|
|
|
+ set (ANDROID_RTTI 1)
|
|
|
+ cmake_dependent_option (ANDROID_EXCEPTIONS "Set ON to enable C++ exceptions" TRUE "NOT ANDROID_STL_FORCE_FEATURES" TRUE)
|
|
|
+ if (NOT FEATURE_SIGNATURE STREQUAL "${ANDROID_STL_FORCE_FEATURES}-${ANDROID_RTTI}-${ANDROID_EXCEPTIONS}")
|
|
|
+ set (INVALIDATE_CCT 1)
|
|
|
+ set (FEATURE_SIGNATURE "${ANDROID_STL_FORCE_FEATURES}-${ANDROID_RTTI}-${ANDROID_EXCEPTIONS}" CACHE INTERNAL "Signature when the C++ features are last cached")
|
|
|
+ endif ()
|
|
|
+ # Urho3D - warn if static runtime is chosen when using SHARED Urho3D library type
|
|
|
+ if (URHO3D_LIB_TYPE STREQUAL SHARED AND ANDROID_STL MATCHES static)
|
|
|
+ message (WARNING "Using static C++ STL runtime (${ANDROID_STL}) with SHARED Urho3D library type may result in unpredictable runtime behavior.")
|
|
|
+ endif ()
|
|
|
+ if (NOT ANDROID_STL OR NOT ANDROID_STL_SAVED STREQUAL ANDROID_STL)
|
|
|
+ # Urho3D - default to use LLVM libc++ runtime
|
|
|
+ #set (ANDROID_DEFAULT_STL system)
|
|
|
+ if (URHO3D_LIB_TYPE STREQUAL SHARED)
|
|
|
+ set (ANDROID_DEFAULT_STL c++_shared)
|
|
|
+ else ()
|
|
|
+ set (ANDROID_DEFAULT_STL c++_static)
|
|
|
+ endif ()
|
|
|
+ set (ANDROID_STL ${ANDROID_DEFAULT_STL} CACHE STRING "Specify the C++ STL runtime (Android platform only), default to ${ANDROID_DEFAULT_STL}; STLport may only be used when URHO3D_NETWORK is disabled")
|
|
|
+ # Urho3D - proper C++ STL runtime is required to build Urho3D, exclude those that do not cut it
|
|
|
+ #set (ANDROID_SUPPORTED_RUNTIMES system gabi++_static gabi++_shared stlport_static stlport_shared gnustl_static gnustl_shared c++_static c++_shared)
|
|
|
+ set (ANDROID_SUPPORTED_RUNTIMES stlport_static stlport_shared gnustl_static gnustl_shared c++_static c++_shared)
|
|
|
+ set_property (CACHE ANDROID_STL PROPERTY STRINGS ${ANDROID_SUPPORTED_RUNTIMES})
|
|
|
+ list (FIND ANDROID_SUPPORTED_RUNTIMES "${ANDROID_STL}" FOUND_INDEX) # Stringify as the actual variable may be empty
|
|
|
+ if (FOUND_INDEX EQUAL -1)
|
|
|
+ string (REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_RUNTIMES "\"${ANDROID_SUPPORTED_RUNTIMES}\"")
|
|
|
+ message (FATAL_ERROR "Unrecognized '${ANDROID_STL}' specified in the ANDROID_STL option, "
|
|
|
+ "supported values are: ${PRINTABLE_ANDROID_SUPPORTED_RUNTIMES}.")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_STL STREQUAL system)
|
|
|
+ if (ANDROID_STL_FORCE_FEATURES)
|
|
|
+ set (ANDROID_RTTI 0)
|
|
|
+ set (ANDROID_EXCEPTIONS 0)
|
|
|
+ endif ()
|
|
|
+ set (STL_LIBS stdc++)
|
|
|
+ # If the 'system' runtime is used in combination with RTTI or C++ exceptions then automatically link against the GNU libsupc++ for now
|
|
|
+ if (ANDROID_RTTI OR ANDROID_EXCEPTIONS)
|
|
|
+ set (STL_LIBS ${STL_LIBS} supc++)
|
|
|
+ endif ()
|
|
|
+ set (STL_INCLUDE_DIRS ${ANDROID_NDK}/sources/cxx-stl/system/include)
|
|
|
+ elseif (ANDROID_STL MATCHES gabi\\+\\+)
|
|
|
+ set (STL_INCLUDE_DIRS ${ANDROID_NDK}/sources/cxx-stl/gabi++/include)
|
|
|
+ elseif (ANDROID_STL MATCHES stlport)
|
|
|
+ set (STL_LIBS ${ANDROID_STL})
|
|
|
+ set (STL_LIBRARY_DIR ${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME})
|
|
|
+ set (STL_INCLUDE_DIRS ${ANDROID_NDK}/sources/cxx-stl/stlport/stlport) # This is not a typo!
|
|
|
+ elseif (ANDROID_STL MATCHES gnustl)
|
|
|
+ set (STL_LIBS ${ANDROID_STL} supc++)
|
|
|
+ set (STL_LIBRARY_DIR ${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.9/libs/${ANDROID_NDK_ABI_NAME})
|
|
|
+ set (STL_INCLUDE_DIRS ${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.9/include ${STL_LIBRARY_DIR}/include)
|
|
|
+ elseif (ANDROID_STL MATCHES c\\+\\+)
|
|
|
+ set (STL_LIBS c++)
|
|
|
+ # TODO: Remove this once libgcc.a is not being used
|
|
|
+ set (GCC_FIX "-Wl,-z,muldefs")
|
|
|
+ set (STL_LIBRARY_DIR ${ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${ANDROID_NDK_ABI_NAME})
|
|
|
+ if (EXISTS ${ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libcxx)
|
|
|
+ set (LIBCXX libcxx/)
|
|
|
+ set (LIBCXXABI libcxxabi/)
|
|
|
+ endif ()
|
|
|
+ set (STL_INCLUDE_DIRS ${ANDROID_NDK}/sources/cxx-stl/llvm-libc++/${LIBCXX}include ${ANDROID_NDK}/sources/cxx-stl/llvm-libc++abi/${LIBCXXABI}include ${ANDROID_NDK}/sources/android/support/include)
|
|
|
+ endif ()
|
|
|
+ file (GLOB SHARED_LIBS ${CMAKE_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME}/lib*_shared.so)
|
|
|
+ if (SHARED_LIBS)
|
|
|
+ execute_process (COMMAND ${CMAKE_COMMAND} -E remove ${SHARED_LIBS})
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_STL MATCHES shared)
|
|
|
+ execute_process (COMMAND ${CMAKE_COMMAND} -E copy_if_different ${STL_LIBRARY_DIR}/lib${ANDROID_STL}.so ${CMAKE_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME}/lib${ANDROID_STL}.so)
|
|
|
+ endif ()
|
|
|
+ if (STL_LIBS)
|
|
|
+ string (REPLACE ";" " -l" STL_LINKER_FLAGS ";${STL_LIBS}")
|
|
|
+ if (ANDROID_STL MATCHES system|static)
|
|
|
+ set (STL_LINKER_FLAGS "-Wl,-Bstatic ${STL_LINKER_FLAGS} -Wl,-Bdynamic")
|
|
|
+ endif ()
|
|
|
+ set (STL_LINKER_FLAGS "-L${STL_LIBRARY_DIR} ${STL_LINKER_FLAGS} ${GCC_FIX}")
|
|
|
+ else ()
|
|
|
+ set (STL_LINKER_FLAGS)
|
|
|
+ endif ()
|
|
|
+ foreach (VAR ANDROID_RTTI ANDROID_EXCEPTIONS STL_INCLUDE_DIRS STL_LIBRARY_DIR STL_LINKER_FLAGS)
|
|
|
+ set (${VAR} ${${VAR}} CACHE INTERNAL "C++ STL runtimes")
|
|
|
+ endforeach ()
|
|
|
+ set (ANDROID_STL_SAVED ${ANDROID_STL} CACHE INTERNAL "Last saved value for ANDROID_STL")
|
|
|
+ endif ()
|
|
|
+
|
|
|
+ # Cross compiler tools
|
|
|
+ if (CMAKE_HOST_WIN32)
|
|
|
+ set (TOOL_EXT .exe)
|
|
|
+ endif ()
|
|
|
+ if (CLANG)
|
|
|
+ set (C_COMPILER clang)
|
|
|
+ set (CXX_COMPILER clang++)
|
|
|
+ else ()
|
|
|
+ set (COMPILER_PREFIX ${ANDROID_TOOLCHAIN_MACHINE_NAME}-)
|
|
|
+ set (C_COMPILER gcc)
|
|
|
+ set (CXX_COMPILER g++)
|
|
|
+ endif ()
|
|
|
+ if (NOT CMAKE_C_COMPILER)
|
|
|
+ set (COMPILER_PATH ${ANDROID_${CLANG}TOOLCHAIN_ROOT}/bin) # CLANG is empty when the compiler is not Clang
|
|
|
+ if ("$ENV{USE_CCACHE}" AND NOT CMAKE_HOST_WIN32)
|
|
|
+ execute_process (COMMAND whereis -b ccache COMMAND grep -o \\S*lib\\S* OUTPUT_VARIABLE CCACHE_SYMLINK ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
|
+ if (CCACHE_SYMLINK AND EXISTS ${CCACHE_SYMLINK}/${COMPILER_PREFIX}${C_COMPILER} AND EXISTS ${CCACHE_SYMLINK}/${COMPILER_PREFIX}${CXX_COMPILER})
|
|
|
+ set (COMPILER_PATH ${CCACHE_SYMLINK})
|
|
|
+ else ()
|
|
|
+ # Fallback to create the ccache symlink in the build tree itself
|
|
|
+ execute_process (COMMAND which ccache RESULT_VARIABLE EXIT_CODE OUTPUT_VARIABLE CCACHE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
|
+ if (EXIT_CODE EQUAL 0 AND CCACHE)
|
|
|
+ foreach (TOOL ${C_COMPILER} ${CXX_COMPILER})
|
|
|
+ execute_process (COMMAND ${CMAKE_COMMAND} -E create_symlink ${CCACHE} ${CMAKE_BINARY_DIR}/${COMPILER_PREFIX}${TOOL})
|
|
|
+ endforeach ()
|
|
|
+ set (COMPILER_PATH ${CMAKE_BINARY_DIR})
|
|
|
+ else ()
|
|
|
+ message (WARNING "ccache may not have been installed on this host system. "
|
|
|
+ "This is required to enable ccache support for Android NDK compiler toolchain. "
|
|
|
+ "CMake has been configured to use the actual compiler toolchain instead of ccache. "
|
|
|
+ "In order to rectify this, the build tree must be regenerated after installing ccache.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ if (NOT COMPILER_PATH STREQUAL ${ANDROID_${CLANG}TOOLCHAIN_ROOT}/bin AND NOT $ENV{PATH} MATCHES ${ANDROID_${CLANG}TOOLCHAIN_ROOT}/bin)
|
|
|
+ message (FATAL_ERROR "The bin directory containing the compiler toolchain (${ANDROID_${CLANG}TOOLCHAIN_ROOT}/bin) has not been added in the PATH environment variable. "
|
|
|
+ "This is required to enable ccache support for Android NDK compiler toolchain.")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ set (CMAKE_C_COMPILER ${COMPILER_PATH}/${COMPILER_PREFIX}${C_COMPILER}${TOOL_EXT} CACHE PATH "C compiler")
|
|
|
+ set (CMAKE_CXX_COMPILER ${COMPILER_PATH}/${COMPILER_PREFIX}${CXX_COMPILER}${TOOL_EXT} CACHE PATH "C++ compiler")
|
|
|
+ set (CMAKE_ASM_COMPILER ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_EXT} CACHE PATH "assembler")
|
|
|
+ set (CMAKE_STRIP ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_EXT} CACHE PATH "strip")
|
|
|
+ set (CMAKE_AR ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc-ar${TOOL_EXT} CACHE PATH "archive")
|
|
|
+ set (CMAKE_LINKER ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ld${TOOL_EXT} CACHE PATH "linker")
|
|
|
+ set (CMAKE_NM ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-nm${TOOL_EXT} CACHE PATH "nm")
|
|
|
+ set (CMAKE_OBJCOPY ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objcopy${TOOL_EXT} CACHE PATH "objcopy")
|
|
|
+ set (CMAKE_OBJDUMP ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objdump${TOOL_EXT} CACHE PATH "objdump")
|
|
|
+ set (CMAKE_RANLIB ${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ranlib${TOOL_EXT} CACHE PATH "ranlib")
|
|
|
+ endif ()
|
|
|
+
|
|
|
+ # Compiler and linker flags
|
|
|
+ if (NOT CMAKE_C_FLAGS OR NOT FLAGS_SIGNATURE STREQUAL "${ANDROID_ABI}-${APP_PLATFORM_LEVEL}-${ANDROID_FORCE_ARM_BUILD}-${ANDROID_STACK_PROTECTION}-${ANDROID_NO_UNDEFINED}-${ANDROID_NOEXECSTACK}-${ANDROID_RELRO}-${ANDROID_FATAL_WARNINGS}-${ANDROID_FORMAT_SECURITY}-${ANDROID_FUNCTION_LEVEL_LINKING}-${ANDROID_STL}-${ANDROID_STL_FORCE_FEATURES}-${ANDROID_RTTI}-${ANDROID_EXCEPTIONS}")
|
|
|
+ set (CMAKE_C_FLAGS "-fsigned-char -funwind-tables -no-canonical-prefixes")
|
|
|
+ set (CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
|
|
|
+ set (CMAKE_C_FLAGS_DEBUG "-O0 -g -DDEBUG -D_DEBUG")
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "-Wl,--build-id -Wl,--warn-shared-textrel")
|
|
|
+ if (CLANG)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT} -target ${ANDROID_LLVM_TRIPLE} -Wno-invalid-command-line-argument -Wno-unused-command-line-argument")
|
|
|
+ set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -fno-limit-debug-info")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_ABI MATCHES armeabi)
|
|
|
+ if (CLANG)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-integrated-as")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_ABI MATCHES -v7a)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a")
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--fix-cortex-a8")
|
|
|
+ elseif (ANDROID_ABI MATCHES -v6)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv6")
|
|
|
+ else ()
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv5te -mtune=xscale")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_ABI MATCHES -v7a|-v6)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=softfp")
|
|
|
+ else ()
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msoft-float")
|
|
|
+ endif ()
|
|
|
+ foreach (FPU neon-vfpv4 neon vfpv4 vfpv3 vfpv3-d16 vfp)
|
|
|
+ if (ANDROID_ABI MATCHES " ${FPU}$")
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=${FPU}")
|
|
|
+ endif ()
|
|
|
+ endforeach ()
|
|
|
+ if (ANDROID_FORCE_ARM_BUILD)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -marm")
|
|
|
+ else ()
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthumb")
|
|
|
+ endif ()
|
|
|
+ elseif (ANDROID_ABI MATCHES mips)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -finline-functions -fmessage-length=0")
|
|
|
+ if (NOT CLANG)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers")
|
|
|
+ endif ()
|
|
|
+ # Clang outputs mips32r2 by default, switch to mips32r1
|
|
|
+ # TODO: Remove this once mipsel-linux-android target is changed in clang
|
|
|
+ if (ANDROID_ABI STREQUAL mips)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mips32")
|
|
|
+ endif ()
|
|
|
+ endif ()
|
|
|
+ # The ld.bfd needs help to find the location of the rooted shared libraries while ld.gold doesn't
|
|
|
+ # TODO: Remove this once gold linker is the default for all the archs or when it is not possible to switch to use ld.bfd
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-rpath-link,\"${CMAKE_SYSROOT}/usr/lib\":\"${CMAKE_SYSROOT}/lib\":\"${STL_LIBRARY_DIR}\"")
|
|
|
+ option (ANDROID_STACK_PROTECTION "Force the addition of a stack canary that checks for stack smashing")
|
|
|
+ if (ANDROID_STACK_PROTECTION)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-strong")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_NO_UNDEFINED "Ensure that a binary doesn't reference undefined symbols" TRUE)
|
|
|
+ if (ANDROID_NO_UNDEFINED)
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_NOEXECSTACK "Enforce the NX (no execute) security feature in the generated machine code" TRUE)
|
|
|
+ if (ANDROID_NOEXECSTACK)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wa,--noexecstack")
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,noexecstack")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_RELRO "Mark certain regions of the resulting executable or shared library as being read-only" TRUE)
|
|
|
+ if (ANDROID_RELRO)
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,relro -Wl,-z,now")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_FATAL_WARNINGS "Treat all linker warnings as errors" TRUE)
|
|
|
+ if (ANDROID_FATAL_WARNINGS)
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--fatal-warnings")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_FORMAT_SECURITY "Provide compiler protection against format string vulnerabilities" TRUE)
|
|
|
+ if (ANDROID_FORMAT_SECURITY)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wformat -Werror=format-security")
|
|
|
+ endif ()
|
|
|
+ option (ANDROID_FUNCTION_LEVEL_LINKING "Split data/function sections and garbage collect unused sections at link time" TRUE)
|
|
|
+ if (ANDROID_FUNCTION_LEVEL_LINKING)
|
|
|
+ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdata-sections -ffunction-sections")
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections")
|
|
|
+ endif ()
|
|
|
+ # RelWithDebInfo and MinSizeRel build configurations are just derivative of Release build configuration
|
|
|
+ string (REPLACE -O3 "-O2 -g" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE}")
|
|
|
+ string (REPLACE -O3 -Os CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_RELEASE}")
|
|
|
+ foreach (VAR _FLAGS _FLAGS_RELEASE _FLAGS_DEBUG _FLAGS_RELWITHDEBINFO _FLAGS_MINSIZEREL)
|
|
|
+ set (CMAKE_C${VAR} ${CMAKE_C${VAR}} CACHE INTERNAL "C Compiler flags")
|
|
|
+ set (CMAKE_CXX${VAR} ${CMAKE_C${VAR}} CACHE INTERNAL "CXX Compiler flags")
|
|
|
+ endforeach ()
|
|
|
+ # Only CXX compiler can accept these flags
|
|
|
+ if (ANDROID_RTTI)
|
|
|
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti" CACHE INTERNAL "CXX Compiler flags")
|
|
|
+ else ()
|
|
|
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti" CACHE INTERNAL "CXX Compiler flags")
|
|
|
+ endif ()
|
|
|
+ if (ANDROID_EXCEPTIONS)
|
|
|
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions" CACHE INTERNAL "CXX Compiler flags")
|
|
|
+ else ()
|
|
|
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions" CACHE INTERNAL "CXX Compiler flags")
|
|
|
+ endif ()
|
|
|
+ set (CMAKE_EXE_LINKER_FLAGS -Wl,-z,nocopyreloc)
|
|
|
+ if (NOT APP_PLATFORM_LEVEL LESS 16)
|
|
|
+ set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
|
|
|
+ endif ()
|
|
|
+ set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}" CACHE INTERNAL "EXE linker flags")
|
|
|
+ set (CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS} CACHE INTERNAL "SHARED linker flags")
|
|
|
+ set (CMAKE_MODULE_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS} CACHE INTERNAL "MODULE linker flags")
|
|
|
+ set (FLAGS_SIGNATURE "${ANDROID_ABI}-${APP_PLATFORM_LEVEL}-${ANDROID_FORCE_ARM_BUILD}-${ANDROID_STACK_PROTECTION}-${ANDROID_NO_UNDEFINED}-${ANDROID_NOEXECSTACK}-${ANDROID_RELRO}-${ANDROID_FATAL_WARNINGS}-${ANDROID_FORMAT_SECURITY}-${ANDROID_FUNCTION_LEVEL_LINKING}-${ANDROID_STL}-${ANDROID_STL_FORCE_FEATURES}-${ANDROID_RTTI}-${ANDROID_EXCEPTIONS}" CACHE INTERNAL "Signature when the compiler/linker flags are last cached")
|
|
|
+ endif ()
|
|
|
+ # Workaround try_compile() limitation
|
|
|
+ set (ENV{CMAKE_SYSROOT} ${CMAKE_SYSROOT})
|
|
|
+ set (ENV{STL_INCLUDE_DIRS} "${STL_INCLUDE_DIRS}") # Stringify to keep the list together
|
|
|
+ set (ENV{STL_LINKER_FLAGS} "${STL_LINKER_FLAGS}")
|
|
|
+else ()
|
|
|
+ set (CMAKE_SYSROOT $ENV{CMAKE_SYSROOT})
|
|
|
+ set (STL_INCLUDE_DIRS $ENV{STL_INCLUDE_DIRS})
|
|
|
+ set (STL_LINKER_FLAGS $ENV{STL_LINKER_FLAGS})
|
|
|
+endif ()
|
|
|
+include_directories (SYSTEM ${STL_INCLUDE_DIRS})
|
|
|
+# Cannot use link_directories() and link_libraries() commands here because CMake will emit the linker flags in an undesirable order
|
|
|
+# Workaround the problem by injecting the linker flags the last explicitly in the CMake build rules
|
|
|
+# This is a hack as it relies on internal implementation, i.e. the hard-coded rules must be kept in sync manually with CMake's Modules/CMakeCXXInformation.cmake file
|
|
|
+set (CMAKE_CXX_CREATE_SHARED_LIBRARY "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES> ${STL_LINKER_FLAGS}")
|
|
|
+set (CMAKE_CXX_CREATE_SHARED_MODULE "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES> ${STL_LINKER_FLAGS}")
|
|
|
+set (CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_CXX_COMPILER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> ${STL_LINKER_FLAGS}")
|
|
|
+
|
|
|
+# Only search libraries and headers in sysroot
|
|
|
+set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
|
|
|
+set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
|
|
|
+set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
|
|
|
+
|
|
|
+# Use response files on Windows host to avoid failure in the linking phase with too long command line
|
|
|
+if (CMAKE_HOST_WIN32)
|
|
|
+ set (CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS 1)
|
|
|
+ set (CMAKE_CXX_USE_RESPONSE_FILE_FOR_OBJECTS 1)
|
|
|
+endif ()
|
Rokas Kupstys