blob: 60c4c6e770d05ab8522244a0e59a98bc64daf4e9 [file] [log] [blame]
# Copyright (C) 2016 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
cmake_minimum_required(VERSION 3.6.0)
# Subsequent toolchain loading is not really needed.
if(DEFINED CMAKE_CROSSCOMPILING)
return()
endif()
# Touch toolchain variable to suppress "unused variable" warning.
if(CMAKE_TOOLCHAIN_FILE)
endif()
# Compatibility for configurable variables.
# Compatible with configurable variables from the other toolchain file:
# https://github.com/taka-no-me/android-cmake
# TODO: We should consider dropping compatibility to simplify things once most
# of our users have migrated to our standard set of configurable variables.
if(ANDROID_TOOLCHAIN_NAME AND NOT ANDROID_TOOLCHAIN)
if(ANDROID_TOOLCHAIN_NAME MATCHES "-clang([0-9].[0-9])?$")
set(ANDROID_TOOLCHAIN clang)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "-[0-9].[0-9]$")
set(ANDROID_TOOLCHAIN gcc)
endif()
endif()
if(ANDROID_ABI STREQUAL "armeabi-v7a with NEON")
set(ANDROID_ABI armeabi-v7a)
set(ANDROID_ARM_NEON TRUE)
elseif(ANDROID_TOOLCHAIN_NAME AND NOT ANDROID_ABI)
if(ANDROID_TOOLCHAIN_NAME MATCHES "^arm-linux-androideabi-")
set(ANDROID_ABI armeabi-v7a)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "^aarch64-linux-android-")
set(ANDROID_ABI arm64-v8a)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "^x86-")
set(ANDROID_ABI x86)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "^x86_64-")
set(ANDROID_ABI x86_64)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "^mipsel-linux-android-")
set(ANDROID_ABI mips)
elseif(ANDROID_TOOLCHAIN_NAME MATCHES "^mips64el-linux-android-")
set(ANDROID_ABI mips64)
endif()
endif()
if(ANDROID_NATIVE_API_LEVEL AND NOT ANDROID_PLATFORM)
if(ANDROID_NATIVE_API_LEVEL MATCHES "^android-[0-9]+$")
set(ANDROID_PLATFORM ${ANDROID_NATIVE_API_LEVEL})
elseif(ANDROID_NATIVE_API_LEVEL MATCHES "^[0-9]+$")
set(ANDROID_PLATFORM android-${ANDROID_NATIVE_API_LEVEL})
endif()
endif()
if(DEFINED ANDROID_APP_PIE AND NOT DEFINED ANDROID_PIE)
set(ANDROID_PIE "${ANDROID_APP_PIE}")
endif()
if(ANDROID_STL_FORCE_FEATURES AND NOT DEFINED ANDROID_CPP_FEATURES)
set(ANDROID_CPP_FEATURES "rtti exceptions")
endif()
if(DEFINED ANDROID_NO_UNDEFINED AND NOT DEFINED ANDROID_ALLOW_UNDEFINED_SYMBOLS)
if(ANDROID_NO_UNDEFINED)
set(ANDROID_ALLOW_UNDEFINED_SYMBOLS FALSE)
else()
set(ANDROID_ALLOW_UNDEFINED_SYMBOLS TRUE)
endif()
endif()
if(DEFINED ANDROID_SO_UNDEFINED AND NOT DEFINED ANDROID_ALLOW_UNDEFINED_SYMBOLS)
set(ANDROID_ALLOW_UNDEFINED_SYMBOLS "${ANDROID_SO_UNDEFINED}")
endif()
if(DEFINED ANDROID_FORCE_ARM_BUILD AND NOT ANDROID_ARM_MODE)
if(ANDROID_FORCE_ARM_BUILD)
set(ANDROID_ARM_MODE arm)
else()
set(ANDROID_ARM_MODE thumb)
endif()
endif()
if(DEFINED ANDROID_NOEXECSTACK AND NOT DEFINED ANDROID_DISABLE_NO_EXECUTE)
if(ANDROID_NOEXECSTACK)
set(ANDROID_DISABLE_NO_EXECUTE FALSE)
else()
set(ANDROID_DISABLE_NO_EXECUTE TRUE)
endif()
endif()
if(DEFINED ANDROID_RELRO AND NOT DEFINED ANDROID_DISABLE_RELRO)
if(ANDROID_RELRO)
set(ANDROID_DISABLE_RELRO FALSE)
else()
set(ANDROID_DISABLE_RELRO TRUE)
endif()
endif()
if(NDK_CCACHE AND NOT ANDROID_CCACHE)
set(ANDROID_CCACHE "${NDK_CCACHE}")
endif()
# Default values for configurable variables.
if(NOT ANDROID_NDK)
if(DEFINED ENV{ANDROID_NDK_HOME}
AND IS_DIRECTORY "$ENV{ANDROID_NDK_HOME}")
set(ANDROID_NDK "$ENV{ANDROID_NDK_HOME}")
elseif(DEFINED ENV{ANDROID_HOME}
AND IS_DIRECTORY "$ENV{ANDROID_HOME}/ndk-bundle")
set(ANDROID_NDK "$ENV{ANDROID_HOME}/ndk-bundle")
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Linux
AND IS_DIRECTORY "$ENV{HOME}/Android/Sdk/ndk-bundle")
set(ANDROID_NDK "$ENV{HOME}/Android/Sdk/ndk-bundle")
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Darwin
AND IS_DIRECTORY "$ENV{HOME}/Library/Android/sdk/ndk-bundle")
set(ANDROID_NDK "$ENV{HOME}/Library/Android/sdk/ndk-bundle")
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows
AND IS_DIRECTORY "$ENV{LOCALAPPDATA}/Android/Sdk/ndk-bundle")
set(ANDROID_NDK "$ENV{LOCALAPPDATA}/Android/Sdk/ndk-bundle")
else()
message(FATAL_ERROR "Android NDK unspecified.")
endif()
endif()
file(TO_CMAKE_PATH "${ANDROID_NDK}" ANDROID_NDK)
if(NOT ANDROID_TOOLCHAIN)
set(ANDROID_TOOLCHAIN clang)
endif()
if(NOT ANDROID_ABI)
set(ANDROID_ABI armeabi-v7a)
endif()
if(ANDROID_PLATFORM MATCHES "^android-(10|11)$")
set(ANDROID_PLATFORM android-9)
elseif(ANDROID_PLATFORM STREQUAL android-20)
set(ANDROID_PLATFORM android-19)
elseif(NOT ANDROID_PLATFORM)
if(ANDROID_ABI MATCHES "64(-v8a)?$")
set(ANDROID_PLATFORM android-21)
else()
set(ANDROID_PLATFORM android-9)
endif()
endif()
string(REPLACE "android-" "" ANDROID_PLATFORM_LEVEL ${ANDROID_PLATFORM})
if(NOT ANDROID_STL)
set(ANDROID_STL gnustl_static)
endif()
if(NOT DEFINED ANDROID_PIE)
if(ANDROID_PLATFORM_LEVEL LESS 16)
set(ANDROID_PIE FALSE)
else()
set(ANDROID_PIE TRUE)
endif()
endif()
if(NOT ANDROID_ARM_MODE)
set(ANDROID_ARM_MODE thumb)
endif()
# Configurable variables.
# Modeled after the ndk-build system.
# For any variables defined in:
# https://developer.android.com/ndk/guides/android_mk.html
# https://developer.android.com/ndk/guides/application_mk.html
# if it makes sense for CMake, then replace LOCAL, APP, or NDK with ANDROID, and
# we have that variable below.
# The exception is ANDROID_TOOLCHAIN vs NDK_TOOLCHAIN_VERSION.
# Since we only have one version of each gcc and clang, specifying a version
# doesn't make much sense.
set(ANDROID_NDK "${ANDROID_NDK}" CACHE FILEPATH "Android NDK")
set(ANDROID_TOOLCHAIN "${ANDROID_TOOLCHAIN}" CACHE STRING "Android toolchain")
set(ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "Android ABI")
set(ANDROID_PLATFORM "${ANDROID_PLATFORM}" CACHE STRING "Android platform")
set(ANDROID_STL "${ANDROID_STL}" CACHE STRING "Android STL")
set(ANDROID_PIE "${ANDROID_PIE}" CACHE BOOL "Android PIE")
set(ANDROID_CPP_FEATURES "${ANDROID_CPP_FEATURES}" CACHE STRING "Android C++ features")
set(ANDROID_ALLOW_UNDEFINED_SYMBOLS "${ANDROID_ALLOW_UNDEFINED_SYMBOLS}" CACHE BOOL "Android allow undefined symbols")
set(ANDROID_ARM_MODE "${ANDROID_ARM_MODE}" CACHE STRING "Android ARM mode")
set(ANDROID_ARM_NEON "${ANDROID_ARM_NEON}" CACHE BOOL "Android ARM NEON")
set(ANDROID_DISABLE_NO_EXECUTE "${ANDROID_DISABLE_NO_EXECUTE}" CACHE BOOL "Android disable no execute")
set(ANDROID_DISABLE_RELRO "${ANDROID_DISABLE_RELRO}" CACHE BOOL "Android disable relocation read-only")
set(ANDROID_DISABLE_FORMAT_STRING_CHECKS "${ANDROID_DISABLE_FORMAT_STRING_CHECKS}" CACHE BOOL "Android disable format string checks")
set(ANDROID_CCACHE "${ANDROID_CCACHE}" CACHE FILEPATH "Android ccache")
# Export configurable variables for the try_compile() command.
set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
ANDROID_NDK
ANDROID_TOOLCHAIN
ANDROID_ABI
ANDROID_PLATFORM
ANDROID_STL
ANDROID_PIE
ANDROID_CPP_FEATURES
ANDROID_ALLOW_UNDEFINED_SYMBOLS
ANDROID_ARM_MODE
ANDROID_ARM_NEON
ANDROID_DISABLE_NO_EXECUTE
ANDROID_DISABLE_RELRO
ANDROID_DISABLE_FORMAT_STRING_CHECKS
ANDROID_CCACHE)
# Standard cross-compiling stuff.
set(ANDROID TRUE)
set(CMAKE_SYSTEM_NAME Android)
set(CMAKE_SYSTEM_VERSION ${ANDROID_PLATFORM_LEVEL})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH)
# ABI.
set(CMAKE_ANDROID_ARCH_ABI ${ANDROID_ABI})
if(ANDROID_ABI MATCHES "^armeabi(-v7a)?$")
set(ANDROID_SYSROOT_ABI arm)
set(ANDROID_TOOLCHAIN_NAME arm-linux-androideabi)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_TOOLCHAIN_NAME})
if(ANDROID_ABI STREQUAL armeabi)
set(CMAKE_SYSTEM_PROCESSOR armv5te)
set(ANDROID_LLVM_TRIPLE armv5te-none-linux-androideabi)
elseif(ANDROID_ABI STREQUAL armeabi-v7a)
set(CMAKE_SYSTEM_PROCESSOR armv7-a)
set(ANDROID_LLVM_TRIPLE armv7-none-linux-androideabi)
endif()
elseif(ANDROID_ABI STREQUAL arm64-v8a)
set(ANDROID_SYSROOT_ABI arm64)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
set(ANDROID_TOOLCHAIN_NAME aarch64-linux-android)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_TOOLCHAIN_NAME})
set(ANDROID_LLVM_TRIPLE aarch64-none-linux-android)
elseif(ANDROID_ABI STREQUAL x86)
set(ANDROID_SYSROOT_ABI x86)
set(CMAKE_SYSTEM_PROCESSOR i686)
set(ANDROID_TOOLCHAIN_NAME i686-linux-android)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_ABI})
set(ANDROID_LLVM_TRIPLE i686-none-linux-android)
elseif(ANDROID_ABI STREQUAL x86_64)
set(ANDROID_SYSROOT_ABI x86_64)
set(CMAKE_SYSTEM_PROCESSOR x86_64)
set(ANDROID_TOOLCHAIN_NAME x86_64-linux-android)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_ABI})
set(ANDROID_LLVM_TRIPLE x86_64-none-linux-android)
elseif(ANDROID_ABI STREQUAL mips)
set(ANDROID_SYSROOT_ABI mips)
set(CMAKE_SYSTEM_PROCESSOR mips)
set(ANDROID_TOOLCHAIN_NAME mipsel-linux-android)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_TOOLCHAIN_NAME})
set(ANDROID_LLVM_TRIPLE mipsel-none-linux-android)
elseif(ANDROID_ABI STREQUAL mips64)
set(ANDROID_SYSROOT_ABI mips64)
set(CMAKE_SYSTEM_PROCESSOR mips64)
set(ANDROID_TOOLCHAIN_NAME mips64el-linux-android)
set(ANDROID_TOOLCHAIN_ROOT ${ANDROID_TOOLCHAIN_NAME})
set(ANDROID_LLVM_TRIPLE mips64el-none-linux-android)
else()
message(FATAL_ERROR "Invalid Android ABI: ${ANDROID_ABI}.")
endif()
# STL.
set(ANDROID_STL_STATIC_LIBRARIES)
set(ANDROID_STL_SHARED_LIBRARIES)
if(ANDROID_STL STREQUAL system)
set(ANDROID_STL_STATIC_LIBRARIES
supc++)
elseif(ANDROID_STL STREQUAL stlport_static)
set(ANDROID_STL_STATIC_LIBRARIES
stlport_static)
elseif(ANDROID_STL STREQUAL stlport_shared)
set(ANDROID_STL_SHARED_LIBRARIES
stlport_shared)
elseif(ANDROID_STL STREQUAL gnustl_static)
set(ANDROID_STL_STATIC_LIBRARIES
gnustl_static)
elseif(ANDROID_STL STREQUAL gnustl_shared)
set(ANDROID_STL_STATIC_LIBRARIES
supc++)
set(ANDROID_STL_SHARED_LIBRARIES
gnustl_shared)
elseif(ANDROID_STL STREQUAL c++_static)
set(ANDROID_STL_STATIC_LIBRARIES
c++_static
c++abi
unwind
android_support)
elseif(ANDROID_STL STREQUAL c++_shared)
set(ANDROID_STL_STATIC_LIBRARIES
unwind)
set(ANDROID_STL_SHARED_LIBRARIES
c++_shared)
elseif(ANDROID_STL STREQUAL none)
else()
message(FATAL_ERROR "Invalid Android STL: ${ANDROID_STL}.")
endif()
# Sysroot.
set(CMAKE_SYSROOT "${ANDROID_NDK}/platforms/${ANDROID_PLATFORM}/arch-${ANDROID_SYSROOT_ABI}")
# Toolchain.
if(CMAKE_HOST_SYSTEM_NAME STREQUAL Linux)
set(ANDROID_HOST_TAG linux-x86_64)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Darwin)
set(ANDROID_HOST_TAG darwin-x86_64)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
set(ANDROID_HOST_TAG windows-x86_64)
endif()
set(ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_ROOT}-4.9/prebuilt/${ANDROID_HOST_TAG}")
set(ANDROID_TOOLCHAIN_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_NAME}-")
if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
set(ANDROID_TOOLCHAIN_SUFFIX .exe)
endif()
if(ANDROID_TOOLCHAIN STREQUAL clang)
set(ANDROID_LLVM_TOOLCHAIN_PREFIX "${ANDROID_NDK}/toolchains/llvm/prebuilt/${ANDROID_HOST_TAG}/bin/")
set(ANDROID_C_COMPILER "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang${ANDROID_TOOLCHAIN_SUFFIX}")
set(ANDROID_CXX_COMPILER "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang++${ANDROID_TOOLCHAIN_SUFFIX}")
# Clang can fail to compile if CMake doesn't correctly supply the target and
# external toolchain, but to do so, CMake needs to already know that the
# compiler is clang. Tell CMake that the compiler is really clang, but don't
# use CMakeForceCompiler, since we still want compile checks. We only want
# to skip the compiler ID detection step.
set(CMAKE_C_COMPILER_ID_RUN TRUE)
set(CMAKE_CXX_COMPILER_ID_RUN TRUE)
set(CMAKE_C_COMPILER_ID Clang)
set(CMAKE_CXX_COMPILER_ID Clang)
set(CMAKE_C_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE})
set(CMAKE_CXX_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE})
set(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}")
set(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}")
elseif(ANDROID_TOOLCHAIN STREQUAL gcc)
set(ANDROID_C_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}gcc${ANDROID_TOOLCHAIN_SUFFIX}")
set(ANDROID_CXX_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}g++${ANDROID_TOOLCHAIN_SUFFIX}")
else()
message(FATAL_ERROR "Invalid Android toolchain: ${ANDROID_TOOLCHAIN}.")
endif()
# Check that the NDK is valid.
if(NOT IS_DIRECTORY "${ANDROID_NDK}"
OR NOT IS_DIRECTORY "${ANDROID_NDK}/platforms"
OR NOT IS_DIRECTORY "${ANDROID_NDK}/prebuilt"
OR NOT IS_DIRECTORY "${ANDROID_NDK}/sources"
OR NOT IS_DIRECTORY "${ANDROID_NDK}/toolchains")
message(FATAL_ERROR "Invalid Android NDK: ${ANDROID_NDK}.")
elseif(NOT IS_DIRECTORY "${ANDROID_NDK}/platforms/${ANDROID_PLATFORM}")
message(FATAL_ERROR "Invalid Android platform: ${ANDROID_PLATFORM}.")
elseif(NOT IS_DIRECTORY "${CMAKE_SYSROOT}")
message(FATAL_ERROR "Invalid Android ABI for platform ${ANDROID_PLATFORM}: ${ANDROID_ABI}.")
endif()
set(ANDROID_NDK_REVISION 12)
file(READ "${ANDROID_NDK}/source.properties" ANDROID_NDK_SOURCE_PROPERTIES)
set(ANDROID_NDK_SOURCE_PROPERTIES_REGEX
"^Pkg\\.Desc = Android NDK\nPkg\\.Revision = ([0-9]+\\.[0-9]+\\.[0-9]+(-beta[0-9]+)?)\n$")
if(NOT ANDROID_NDK_SOURCE_PROPERTIES MATCHES "${ANDROID_NDK_SOURCE_PROPERTIES_REGEX}")
message(FATAL_ERROR "Failed to parse Android NDK revision: ${ANDROID_NDK}/source.properties.")
endif()
string(REGEX REPLACE "${ANDROID_NDK_SOURCE_PROPERTIES_REGEX}" "\\1"
ANDROID_NDK_PACKAGE_REVISION "${ANDROID_NDK_SOURCE_PROPERTIES}")
if(NOT ANDROID_NDK_PACKAGE_REVISION MATCHES "^${ANDROID_NDK_REVISION}\\.")
message(FATAL_ERROR "Invalid Android NDK revision (should be ${ANDROID_NDK_REVISION}): ${ANDROID_NDK_PACKAGE_REVISION}.")
endif()
set(ANDROID_COMPILER_FLAGS)
set(ANDROID_COMPILER_FLAGS_CXX)
set(ANDROID_COMPILER_FLAGS_DEBUG)
set(ANDROID_COMPILER_FLAGS_RELEASE)
set(ANDROID_LINKER_FLAGS)
set(ANDROID_LINKER_FLAGS_EXE)
# Generic flags.
list(APPEND ANDROID_COMPILER_FLAGS
-g
-DANDROID
-ffunction-sections
-funwind-tables
-fstack-protector-strong
-no-canonical-prefixes)
list(APPEND ANDROID_COMPILER_FLAGS_CXX
-fno-exceptions
-fno-rtti)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,--build-id
-Wl,--warn-shared-textrel
-Wl,--fatal-warnings)
list(APPEND ANDROID_LINKER_FLAGS_EXE
-Wl,--gc-sections
-Wl,-z,nocopyreloc)
# Debug and release flags.
list(APPEND ANDROID_COMPILER_FLAGS_DEBUG
-O0)
if(ANDROID_ABI MATCHES "^armeabi")
list(APPEND ANDROID_COMPILER_FLAGS_RELEASE
-Os)
else()
list(APPEND ANDROID_COMPILER_FLAGS_RELEASE
-O2)
endif()
list(APPEND ANDROID_COMPILER_FLAGS_RELEASE
-DNDEBUG)
if(ANDROID_TOOLCHAIN STREQUAL clang)
list(APPEND ANDROID_COMPILER_FLAGS_DEBUG
-fno-limit-debug-info)
endif()
# Toolchain and ABI specific flags.
if(ANDROID_ABI STREQUAL armeabi)
list(APPEND ANDROID_COMPILER_FLAGS
-march=armv5te
-mtune=xscale
-msoft-float)
endif()
if(ANDROID_ABI STREQUAL armeabi-v7a)
list(APPEND ANDROID_COMPILER_FLAGS
-march=armv7-a
-mfloat-abi=softfp
-mfpu=vfpv3-d16)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,--fix-cortex-a8)
endif()
if(ANDROID_ABI MATCHES "^armeabi" AND ANDROID_TOOLCHAIN STREQUAL clang)
# Disable integrated-as for better compatibility.
list(APPEND ANDROID_COMPILER_FLAGS
-fno-integrated-as)
endif()
if(ANDROID_ABI STREQUAL mips AND ANDROID_TOOLCHAIN STREQUAL clang)
list(APPEND ANDROID_COMPILER_FLAGS
-mips32)
endif()
# STL specific flags.
if(ANDROID_STL STREQUAL system)
set(ANDROID_STL_PREFIX gnu-libstdc++/4.9)
set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES
"${ANDROID_NDK}/sources/cxx-stl/system/include")
elseif(ANDROID_STL MATCHES "^stlport_")
set(ANDROID_STL_PREFIX stlport)
set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/stlport"
"${ANDROID_NDK}/sources/cxx-stl/gabi++/include")
elseif(ANDROID_STL MATCHES "^gnustl_")
set(ANDROID_STL_PREFIX gnu-libstdc++/4.9)
set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/include"
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/include"
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/include/backward")
elseif(ANDROID_STL MATCHES "^c\\+\\+_")
set(ANDROID_STL_PREFIX llvm-libc++)
if(ANDROID_ABI MATCHES "^armeabi")
list(APPEND ANDROID_LINKER_FLAGS
-Wl,--exclude-libs,libunwind.a)
else()
list(REMOVE_ITEM ANDROID_STL_STATIC_LIBRARIES
unwind)
endif()
list(APPEND ANDROID_COMPILER_FLAGS_CXX
-std=c++11)
if(ANDROID_TOOLCHAIN STREQUAL gcc)
list(APPEND ANDROID_COMPILER_FLAGS_CXX
-fno-strict-aliasing)
endif()
set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libcxx/include"
"${ANDROID_NDK}/sources/android/support/include"
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}abi/libcxxabi/include")
endif()
set(ANDROID_CXX_STANDARD_LIBRARIES)
foreach(library ${ANDROID_STL_STATIC_LIBRARIES})
list(APPEND ANDROID_CXX_STANDARD_LIBRARIES
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/lib${library}.a")
endforeach()
foreach(library ${ANDROID_STL_SHARED_LIBRARIES})
list(APPEND ANDROID_CXX_STANDARD_LIBRARIES
"${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/lib${library}.so")
endforeach()
if(ANDROID_ABI STREQUAL armeabi AND NOT ANDROID_STL MATCHES "^(none|system)$")
list(APPEND ANDROID_CXX_STANDARD_LIBRARIES
-latomic)
endif()
string(REPLACE ";" " " ANDROID_CXX_STANDARD_LIBRARIES "${ANDROID_CXX_STANDARD_LIBRARIES}")
set(CMAKE_CXX_STANDARD_LIBRARIES "${ANDROID_CXX_STANDARD_LIBRARIES}")
# Configuration specific flags.
if(ANDROID_PIE)
set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
list(APPEND ANDROID_LINKER_FLAGS_EXE
-pie
-fPIE)
endif()
if(ANDROID_CPP_FEATURES)
separate_arguments(ANDROID_CPP_FEATURES)
foreach(feature ${ANDROID_CPP_FEATURES})
if(NOT ${feature} MATCHES "^(rtti|exceptions)$")
message(FATAL_ERROR "Invalid Android C++ feature: ${feature}.")
endif()
list(APPEND ANDROID_COMPILER_FLAGS_CXX
-f${feature})
endforeach()
string(REPLACE ";" " " ANDROID_CPP_FEATURES "${ANDROID_CPP_FEATURES}")
endif()
if(NOT ANDROID_ALLOW_UNDEFINED_SYMBOLS)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,--no-undefined)
endif()
if(ANDROID_ABI MATCHES "armeabi")
if(ANDROID_ARM_MODE STREQUAL thumb)
list(APPEND ANDROID_COMPILER_FLAGS
-mthumb)
elseif(ANDROID_ARM_MODE STREQUAL arm)
list(APPEND ANDROID_COMPILER_FLAGS
-marm)
else()
message(FATAL_ERROR "Invalid Android ARM mode: ${ANDROID_ARM_MODE}.")
endif()
if(ANDROID_STL STREQUAL armeabi-v7a AND ANDROID_ARM_NEON)
list(APPEND ANDROID_COMPILER_FLAGS
-mfpu=neon)
endif()
endif()
if(ANDROID_DISABLE_NO_EXECUTE)
list(APPEND ANDROID_COMPILER_FLAGS
-Wa,--execstack)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,-z,execstack)
else()
list(APPEND ANDROID_COMPILER_FLAGS
-Wa,--noexecstack)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,-z,noexecstack)
endif()
if(ANDROID_DISABLE_RELRO)
list(APPEND ANDROID_LINKER_FLAGS
-Wl,-z,norelro -Wl,-z,lazy)
else()
list(APPEND ANDROID_LINKER_FLAGS
-Wl,-z,relro -Wl,-z,now)
endif()
if(ANDROID_DISABLE_FORMAT_STRING_CHECKS)
list(APPEND ANDROID_COMPILER_FLAGS
-Wno-error=format-security)
else()
list(APPEND ANDROID_COMPILER_FLAGS
-Wformat -Werror=format-security)
endif()
# Convert these lists into strings.
string(REPLACE ";" " " ANDROID_COMPILER_FLAGS "${ANDROID_COMPILER_FLAGS}")
string(REPLACE ";" " " ANDROID_COMPILER_FLAGS_CXX "${ANDROID_COMPILER_FLAGS_CXX}")
string(REPLACE ";" " " ANDROID_COMPILER_FLAGS_DEBUG "${ANDROID_COMPILER_FLAGS_DEBUG}")
string(REPLACE ";" " " ANDROID_COMPILER_FLAGS_RELEASE "${ANDROID_COMPILER_FLAGS_RELEASE}")
string(REPLACE ";" " " ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS}")
string(REPLACE ";" " " ANDROID_LINKER_FLAGS_EXE "${ANDROID_LINKER_FLAGS_EXE}")
if(ANDROID_CCACHE)
set(CMAKE_C_COMPILER "${ANDROID_CCACHE}" CACHE FILEPATH "ccache")
set(CMAKE_CXX_COMPILER "${ANDROID_CCACHE}" CACHE FILEPATH "ccache")
set(CMAKE_C_COMPILER_ARG1 "${ANDROID_C_COMPILER}" CACHE FILEPATH "C compiler")
set(CMAKE_CXX_COMPILER_ARG1 "${ANDROID_CXX_COMPILER}" CACHE FILEPATH "C++ compiler")
else()
set(CMAKE_C_COMPILER "${ANDROID_C_COMPILER}" CACHE FILEPATH "C compiler")
set(CMAKE_CXX_COMPILER "${ANDROID_CXX_COMPILER}" CACHE FILEPATH "C++ compiler")
endif()
set(CMAKE_AR "${ANDROID_TOOLCHAIN_PREFIX}gcc-ar${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "ar")
set(CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}gcc${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "asm compiler")
set(CMAKE_LINKER "${ANDROID_TOOLCHAIN_PREFIX}ld${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "linker")
set(CMAKE_NM "${ANDROID_TOOLCHAIN_PREFIX}nm${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "nm")
set(CMAKE_OBJCOPY "${ANDROID_TOOLCHAIN_PREFIX}objcopy${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "objcopy")
set(CMAKE_OBJDUMP "${ANDROID_TOOLCHAIN_PREFIX}objdump${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "objdump")
set(CMAKE_RANLIB "${ANDROID_TOOLCHAIN_PREFIX}ranlib${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "ranlib")
set(CMAKE_STRIP "${ANDROID_TOOLCHAIN_PREFIX}strip${ANDROID_TOOLCHAIN_SUFFIX}" CACHE FILEPATH "strip")
set(CMAKE_C_FLAGS "" CACHE STRING "C flags")
set(CMAKE_CXX_FLAGS "" CACHE STRING "C++ flags")
set(CMAKE_C_FLAGS_DEBUG "" CACHE STRING "C flags debug")
set(CMAKE_CXX_FLAGS_DEBUG "" CACHE STRING "C++ flags debug")
set(CMAKE_C_FLAGS_RELEASE "" CACHE STRING "C flags release")
set(CMAKE_CXX_FLAGS_RELEASE "" CACHE STRING "C++ flags release")
set(CMAKE_MODULE_LINKER_FLAGS "" CACHE STRING "module linker flags")
set(CMAKE_SHARED_LINKER_FLAGS "" CACHE STRING "shared linker flags")
set(CMAKE_EXE_LINKER_FLAGS "" CACHE STRING "executable linker flags")
set(CMAKE_C_FLAGS "${ANDROID_COMPILER_FLAGS} ${CMAKE_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${ANDROID_COMPILER_FLAGS} ${ANDROID_COMPILER_FLAGS_CXX} ${CMAKE_CXX_FLAGS}")
set(CMAKE_C_FLAGS_DEBUG "${ANDROID_COMPILER_FLAGS_DEBUG} ${CMAKE_C_FLAGS_DEBUG}")
set(CMAKE_CXX_FLAGS_DEBUG "${ANDROID_COMPILER_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_RELEASE "${ANDROID_COMPILER_FLAGS_RELEASE} ${CMAKE_C_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS_RELEASE "${ANDROID_COMPILER_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_RELEASE}")
set(CMAKE_SHARED_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${ANDROID_LINKER_FLAGS_EXE} ${CMAKE_EXE_LINKER_FLAGS}")
# Compatibility for read-only variables.
# Read-only variables for compatibility with the other toolchain file.
# We'll keep these around for the existing projects that still use them.
# TODO: All of the variables here have equivalents in our standard set of
# configurable variables, so we can remove these once most of our users migrate
# to those variables.
set(ANDROID_NATIVE_API_LEVEL ${ANDROID_PLATFORM_LEVEL})
if(ANDROID_ALLOW_UNDEFINED_SYMBOLS)
set(ANDROID_SO_UNDEFINED TRUE)
else()
set(ANDROID_NO_UNDEFINED TRUE)
endif()
set(ANDROID_FUNCTION_LEVEL_LINKING TRUE)
set(ANDROID_GOLD_LINKER TRUE)
if(NOT ANDROID_DISABLE_NO_EXECUTE)
set(ANDROID_NOEXECSTACK TRUE)
endif()
if(NOT ANDROID_DISABLE_RELRO)
set(ANDROID_RELRO TRUE)
endif()
if(ANDROID_ARM_MODE STREQUAL arm)
set(ANDROID_FORCE_ARM_BUILD TRUE)
endif()
if(ANDROID_CPP_FEATURES MATCHES "rtti"
AND ANDROID_CPP_FEATURES MATCHES "exceptions")
set(ANDROID_STL_FORCE_FEATURES TRUE)
endif()
if(ANDROID_CCACHE)
set(NDK_CCACHE "${ANDROID_CCACHE}")
endif()
if(ANDROID_TOOLCHAIN STREQUAL clang)
set(ANDROID_TOOLCHAIN_NAME ${ANDROID_TOOLCHAIN_NAME}-clang)
else()
set(ANDROID_TOOLCHAIN_NAME ${ANDROID_TOOLCHAIN_NAME}-4.9)
endif()
set(ANDROID_NDK_HOST_X64 TRUE)
set(ANDROID_NDK_LAYOUT RELEASE)
if(ANDROID_ABI STREQUAL armeabi)
set(ARMEABI TRUE)
elseif(ANDROID_ABI STREQUAL armeabi-v7a)
set(ARMEABI_V7A TRUE)
if(ANDROID_ARM_NEON)
set(NEON TRUE)
endif()
elseif(ANDROID_ABI STREQUAL arm64-v8a)
set(ARM64_V8A TRUE)
elseif(ANDROID_ABI STREQUAL x86)
set(X86 TRUE)
elseif(ANDROID_ABI STREQUAL x86_64)
set(X86_64 TRUE)
elseif(ANDROID_ABI STREQUAL mips)
set(MIPS TRUE)
elseif(ANDROID_ABI STREQUAL MIPS64)
set(MIPS64 TRUE)
endif()
set(ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_HOST_TAG})
set(ANDROID_NDK_ABI_NAME ${ANDROID_ABI})
set(ANDROID_NDK_RELEASE r${ANDROID_NDK_REVISION})
set(ANDROID_ARCH_NAME ${ANDROID_SYSROOT_ABI})
set(ANDROID_SYSROOT "${CMAKE_SYSROOT}")
set(TOOL_OS_SUFFIX ${ANDROID_TOOLCHAIN_SUFFIX})
if(ANDROID_TOOLCHAIN STREQUAL clang)
set(ANDROID_COMPILER_IS_CLANG TRUE)
endif()