mirror of
https://github.com/crystalidea/qt-build-tools.git
synced 2025-07-04 00:15:24 +08:00
qt 6.5.3
This commit is contained in:
kleuter
@ -0,0 +1,2 @@
|
||||
include(Platform/ADSP-Common)
|
||||
__platform_adsp(C)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/ADSP-Common)
|
||||
__platform_adsp(CXX)
|
||||
@ -0,0 +1,36 @@
|
||||
include_guard()
|
||||
|
||||
macro(__platform_adsp_init)
|
||||
if(NOT CMAKE_ADSP_PLATFORM_INITIALIZED)
|
||||
if(NOT CMAKE_SYSTEM_PROCESSOR)
|
||||
message(FATAL_ERROR "ADSP: CMAKE_SYSTEM_PROCESSOR is required but not set")
|
||||
endif()
|
||||
|
||||
set(CMAKE_ADSP_PROCESSOR "ADSP-${CMAKE_SYSTEM_PROCESSOR}")
|
||||
string(TOUPPER "${CMAKE_ADSP_PROCESSOR}" CMAKE_ADSP_PROCESSOR)
|
||||
|
||||
set(CMAKE_ADSP_COMPILER_NAME cc21k.exe)
|
||||
if(CMAKE_ADSP_PROCESSOR MATCHES "^ADSP-BF")
|
||||
set(CMAKE_ADSP_COMPILER_NAME ccblkfn.exe)
|
||||
endif()
|
||||
|
||||
set(CMAKE_ADSP_PLATFORM_INITIALIZED TRUE)
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(__platform_adsp lang)
|
||||
__platform_adsp_init()
|
||||
set(CMAKE_${lang}_COMPILER "${CMAKE_ADSP_ROOT}/${CMAKE_ADSP_COMPILER_NAME}")
|
||||
|
||||
execute_process(
|
||||
COMMAND "${CMAKE_${lang}_COMPILER}" "-proc=${CMAKE_ADSP_PROCESSOR}" "-version"
|
||||
OUTPUT_QUIET ERROR_QUIET
|
||||
RESULT_VARIABLE _adsp_is_valid_proc
|
||||
)
|
||||
if(NOT _adsp_is_valid_proc EQUAL 0)
|
||||
message(FATAL_ERROR
|
||||
"ADSP: unsupported processor '${CMAKE_ADSP_PROCESSOR}' for CMAKE_${lang}_COMPILER:\n"
|
||||
" ${CMAKE_${lang}_COMPILER}"
|
||||
)
|
||||
endif()
|
||||
endmacro()
|
||||
@ -0,0 +1,26 @@
|
||||
if(IS_DIRECTORY "$ENV{ADSP_ROOT}")
|
||||
file(TO_CMAKE_PATH "$ENV{ADSP_ROOT}" CMAKE_ADSP_ROOT)
|
||||
endif()
|
||||
|
||||
macro(_find_adsp_root path_pattern)
|
||||
set(CMAKE_ADSP_ROOT "")
|
||||
set(_adsp_root_version "0")
|
||||
file(GLOB _adsp_root_paths "${path_pattern}")
|
||||
foreach(_current_adsp_root_path IN LISTS _adsp_root_paths)
|
||||
string(REGEX MATCH "([0-9\\.]+)/?$" _current_adsp_root_version "${_current_adsp_root_path}")
|
||||
if(_current_adsp_root_version VERSION_GREATER _adsp_root_version)
|
||||
set(CMAKE_ADSP_ROOT "${_current_adsp_root_path}")
|
||||
set(_adsp_root_version "${_current_adsp_root_version}")
|
||||
endif()
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
if(NOT CMAKE_ADSP_ROOT)
|
||||
_find_adsp_root("C:/Analog Devices/CrossCore Embedded Studio *")
|
||||
endif()
|
||||
if(NOT CMAKE_ADSP_ROOT)
|
||||
_find_adsp_root("C:/Program Files (x86)/Analog Devices/VisualDSP *")
|
||||
endif()
|
||||
if(NOT IS_DIRECTORY "${CMAKE_ADSP_ROOT}")
|
||||
message(FATAL_ERROR "ADSP: could not find CCES/VDSP++ install directory ${CMAKE_ADSP_ROOT}")
|
||||
endif()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/ADSP-Common)
|
||||
__platform_adsp_init()
|
||||
|
||||
set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/AIX-GNU-C)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/AIX-GNU-CXX)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-GNU)
|
||||
__aix_compiler_gnu(ASM)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-GNU)
|
||||
__aix_compiler_gnu(C)
|
||||
@ -0,0 +1,3 @@
|
||||
include(Platform/AIX-GNU)
|
||||
__aix_compiler_gnu(CXX)
|
||||
unset(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-GNU)
|
||||
__aix_compiler_gnu(Fortran)
|
||||
@ -0,0 +1,33 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__AIX_COMPILER_GNU)
|
||||
return()
|
||||
endif()
|
||||
set(__AIX_COMPILER_GNU 1)
|
||||
|
||||
macro(__aix_compiler_gnu lang)
|
||||
set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG "-Wl,-blibpath:")
|
||||
set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP ":")
|
||||
string(APPEND CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS " -Wl,-bnoipath")
|
||||
set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-Wl,-bexpall") # CMP0065 old behavior
|
||||
set(CMAKE_${lang}_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH 1)
|
||||
|
||||
set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath")
|
||||
if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 7 OR CMAKE_SYSTEM_VERSION VERSION_LESS 7.1)
|
||||
unset(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY)
|
||||
endif()
|
||||
|
||||
# Construct the export list ourselves to pass only the object files so
|
||||
# that we export only the symbols actually provided by the sources.
|
||||
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
|
||||
"\"${CMAKE_ROOT}/Modules/Platform/AIX/ExportImportList\" -o <OBJECT_DIR>/exports.exp -c <CMAKE_${lang}_COMPILER> <AIX_EXPORTS> <OBJECTS>"
|
||||
"<CMAKE_${lang}_COMPILER> <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> -Wl,-bE:<OBJECT_DIR>/exports.exp <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
|
||||
)
|
||||
|
||||
set(CMAKE_${lang}_LINK_EXECUTABLE_WITH_EXPORTS
|
||||
"\"${CMAKE_ROOT}/Modules/Platform/AIX/ExportImportList\" -o <TARGET_IMPLIB> -c <CMAKE_${lang}_COMPILER> -l . <AIX_EXPORTS> <OBJECTS>"
|
||||
"<CMAKE_${lang}_COMPILER> <FLAGS> <CMAKE_${lang}_LINK_FLAGS> -Wl,-bE:<TARGET_IMPLIB> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
|
||||
endmacro()
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-IBMClang)
|
||||
__aix_compiler_ibmclang(C)
|
||||
@ -0,0 +1,3 @@
|
||||
include(Platform/AIX-IBMClang)
|
||||
__aix_compiler_ibmclang(CXX)
|
||||
unset(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN)
|
||||
@ -0,0 +1,16 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__AIX_COMPILER_IBMCLANG)
|
||||
return()
|
||||
endif()
|
||||
set(__AIX_COMPILER_IBMCLANG 1)
|
||||
|
||||
include(Platform/AIX-GNU)
|
||||
|
||||
macro(__aix_compiler_ibmclang lang)
|
||||
__aix_compiler_gnu(${lang})
|
||||
unset(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY)
|
||||
endmacro()
|
||||
@ -0,0 +1 @@
|
||||
set(UNIX 1)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/AIX-XL-C)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/AIX-XL-CXX)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/AIX-XL-Fortran)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-XL)
|
||||
__aix_compiler_xl(ASM)
|
||||
@ -0,0 +1,5 @@
|
||||
include(Platform/AIX-XL)
|
||||
__aix_compiler_xl(C)
|
||||
|
||||
# -qhalt=e = Halt on error messages (rather than just severe errors)
|
||||
string(APPEND CMAKE_C_FLAGS_INIT " -qhalt=e")
|
||||
@ -0,0 +1,5 @@
|
||||
include(Platform/AIX-XL)
|
||||
__aix_compiler_xl(CXX)
|
||||
|
||||
# -qhalt=s = Halt on severe error messages
|
||||
string(APPEND CMAKE_CXX_FLAGS_INIT " -qhalt=s")
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-XL)
|
||||
__aix_compiler_xl(Fortran)
|
||||
@ -0,0 +1,41 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__AIX_COMPILER_XL)
|
||||
return()
|
||||
endif()
|
||||
set(__AIX_COMPILER_XL 1)
|
||||
|
||||
macro(__aix_compiler_xl lang)
|
||||
set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG "-Wl,-blibpath:")
|
||||
set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP ":")
|
||||
string(APPEND CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS " -Wl,-bnoipath")
|
||||
set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-Wl,-bexpall") # CMP0065 old behavior
|
||||
set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS " ")
|
||||
set(CMAKE_SHARED_MODULE_${lang}_FLAGS " ")
|
||||
|
||||
set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath")
|
||||
|
||||
set(_OBJECTS " <OBJECTS>")
|
||||
if(DEFINED CMAKE_XL_CreateExportList AND CMAKE_XL_CreateExportList STREQUAL "")
|
||||
# Prior to CMake 3.16, CMAKE_XL_CreateExportList held the path to the XL CreateExportList tool.
|
||||
# Users could set it to an empty value to skip automatic exports in favor of manual -bE: flags.
|
||||
# Preserve that behavior for compatibility (even though it was undocumented).
|
||||
set(_OBJECTS "")
|
||||
endif()
|
||||
|
||||
# Construct the export list ourselves to pass only the object files so
|
||||
# that we export only the symbols actually provided by the sources.
|
||||
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
|
||||
"\"${CMAKE_ROOT}/Modules/Platform/AIX/ExportImportList\" -o <OBJECT_DIR>/exports.exp -c <CMAKE_${lang}_COMPILER> <AIX_EXPORTS>${_OBJECTS}"
|
||||
"<CMAKE_${lang}_COMPILER> <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> -Wl,-bE:<OBJECT_DIR>/exports.exp <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"
|
||||
)
|
||||
|
||||
set(CMAKE_${lang}_LINK_EXECUTABLE_WITH_EXPORTS
|
||||
"\"${CMAKE_ROOT}/Modules/Platform/AIX/ExportImportList\" -o <TARGET_IMPLIB> -c <CMAKE_${lang}_COMPILER> -l . <AIX_EXPORTS> <OBJECTS>"
|
||||
"<CMAKE_${lang}_COMPILER> <FLAGS> <CMAKE_${lang}_LINK_FLAGS> -Wl,-bE:<TARGET_IMPLIB> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
|
||||
|
||||
unset(_OBJECTS)
|
||||
endmacro()
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-XLClang)
|
||||
__aix_compiler_xlclang(C)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/AIX-XLClang)
|
||||
__aix_compiler_xlclang(CXX)
|
||||
@ -0,0 +1,15 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__AIX_COMPILER_XLCLANG)
|
||||
return()
|
||||
endif()
|
||||
set(__AIX_COMPILER_XLCLANG 1)
|
||||
|
||||
include(Platform/AIX-XL)
|
||||
|
||||
macro(__aix_compiler_xlclang lang)
|
||||
__aix_compiler_xl(${lang})
|
||||
endmacro()
|
||||
@ -0,0 +1,33 @@
|
||||
set(CMAKE_SHARED_LIBRARY_PREFIX "lib") # lib
|
||||
set(CMAKE_SHARED_LIBRARY_SUFFIX ".so") # .so
|
||||
set(CMAKE_AIX_IMPORT_FILE_PREFIX "")
|
||||
set(CMAKE_AIX_IMPORT_FILE_SUFFIX ".imp")
|
||||
set(CMAKE_DL_LIBS "-lld")
|
||||
|
||||
# RPATH support on AIX is called libpath. By default the runtime
|
||||
# libpath is paths specified by -L followed by /usr/lib and /lib. In
|
||||
# order to prevent the -L paths from being used we must force use of
|
||||
# -Wl,-blibpath:/usr/lib:/lib whether RPATH support is on or not.
|
||||
# When our own RPATH is to be added it may be inserted before the
|
||||
# "always" paths.
|
||||
if(NOT DEFINED CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH)
|
||||
set(CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH /usr/lib /lib)
|
||||
endif()
|
||||
|
||||
# Files named "libfoo.a" may actually be shared libraries.
|
||||
set_property(GLOBAL PROPERTY TARGET_ARCHIVES_MAY_BE_SHARED_LIBS 1)
|
||||
|
||||
# since .a can be a static or shared library on AIX, we can not do this.
|
||||
# at some point if we wanted it, we would have to figure out if a .a is
|
||||
# static or shared, then we could add this back:
|
||||
|
||||
# Initialize C link type selection flags. These flags are used when
|
||||
# building a shared library, shared module, or executable that links
|
||||
# to other libraries to select whether to use the static or shared
|
||||
# versions of the libraries.
|
||||
#foreach(type SHARED_LIBRARY SHARED_MODULE EXE)
|
||||
# set(CMAKE_${type}_LINK_STATIC_C_FLAGS "-bstatic")
|
||||
# set(CMAKE_${type}_LINK_DYNAMIC_C_FLAGS "-bdynamic")
|
||||
#endforeach()
|
||||
|
||||
include(Platform/UnixPaths)
|
||||
@ -0,0 +1,82 @@
|
||||
#!/bin/sh
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# This script is internal to CMake and meant only to be
|
||||
# invoked by CMake-generated build systems on AIX.
|
||||
|
||||
usage='usage: ExportImportList -o <out-file> -c <compiler> [-l <lib>] [-n] [--] <objects>...'
|
||||
|
||||
die() {
|
||||
echo "$@" 1>&2; exit 1
|
||||
}
|
||||
|
||||
# Process command-line arguments.
|
||||
out=''
|
||||
lib=''
|
||||
no_objects=''
|
||||
compiler=''
|
||||
while test "$#" != 0; do
|
||||
case "$1" in
|
||||
-l) shift; lib="$1" ;;
|
||||
-o) shift; out="$1" ;;
|
||||
-n) no_objects='1' ;;
|
||||
-c) shift; compiler="$1" ;;
|
||||
--) shift; break ;;
|
||||
-*) die "$usage" ;;
|
||||
*) break ;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
test -n "$out" || die "$usage"
|
||||
# We need the compiler executable to resolve where the ibm-llvm-nm executable is
|
||||
test -n "$compiler" || die "$usage"
|
||||
|
||||
# Build a temporary file that atomically replaces the output later.
|
||||
out_tmp="$out.tmp$$"
|
||||
trap 'rm -f "$out_tmp"' EXIT INT TERM
|
||||
> "$out_tmp"
|
||||
|
||||
# If IPA was enabled and a compiler from the IBMClang family is used, then
|
||||
# the object files contain LLVM bitcode[0] rather than XCOFF objects and so
|
||||
# need to be handled differently.
|
||||
#
|
||||
# [0]: https://www.ibm.com/docs/en/openxl-c-and-cpp-aix/17.1.0?topic=compatibility-link-time-optimization-lto
|
||||
NM="$(dirname "$compiler")/../libexec/ibm-llvm-nm"
|
||||
|
||||
function IsBitcode {
|
||||
# N4 = first 4 bytes, -tx = output in hexadecimal, -An = don't display offset
|
||||
# cut: trim off the preceding whitespace where the offset would be
|
||||
# 4243code is the hexadecimal magic number for LLVM bitcode
|
||||
[ "$(od -N4 -tx -An $1 | cut -d ' ' -f 2)" == "4243c0de" ];
|
||||
}
|
||||
|
||||
# Collect symbols exported from all object files.
|
||||
if test -z "$no_objects"; then
|
||||
for f in "$@"; do
|
||||
if IsBitcode "$f"; then
|
||||
"$NM" "$f" --defined-only --extern-only --just-symbol-name 2>/dev/null
|
||||
else
|
||||
dump -tov -X 32_64 "$f" |
|
||||
awk '
|
||||
BEGIN {
|
||||
V["EXPORTED"]=" export"
|
||||
V["PROTECTED"]=" protected"
|
||||
}
|
||||
/^\[[0-9]+\]\tm +[^ ]+ +\.(text|data|bss) +[^ ]+ +(extern|weak) +(EXPORTED|PROTECTED| ) / {
|
||||
if (!match($NF,/^(\.|__sinit|__sterm|__[0-9]+__)/)) {
|
||||
print $NF V[$(NF-1)]
|
||||
}
|
||||
}
|
||||
'
|
||||
fi
|
||||
done >> "$out_tmp"
|
||||
fi
|
||||
|
||||
# Generate the export/import file.
|
||||
{
|
||||
if test -n "$lib"; then
|
||||
echo "#! $lib"
|
||||
fi
|
||||
sort -u "$out_tmp"
|
||||
} > "$out"
|
||||
@ -0,0 +1,9 @@
|
||||
# Define ARTOS to select proper behavior and tell preprocessor to accept C++ style comments.
|
||||
string(APPEND CMAKE_C_FLAGS_INIT " -DARTOS -Xp -+")
|
||||
# ac doesn't support -g properly and doesn't support the normal gcc optimization options. Just use the defaults set by ac.
|
||||
string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ")
|
||||
string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
|
||||
string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
|
||||
string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG")
|
||||
# Most projects expect the stdio functions to be available.
|
||||
set(CMAKE_C_STANDARD_LIBRARIES_INIT "stdio.a")
|
||||
@ -0,0 +1,17 @@
|
||||
# Support for ARTOS RTOS (locamation.com)
|
||||
set(CMAKE_LINK_LIBRARY_SUFFIX "")
|
||||
set(CMAKE_STATIC_LIBRARY_PREFIX "")
|
||||
set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
|
||||
set(CMAKE_SHARED_LIBRARY_PREFIX "")
|
||||
set(CMAKE_SHARED_LIBRARY_SUFFIX ".a")
|
||||
set(CMAKE_EXECUTABLE_SUFFIX ".x")
|
||||
set(CMAKE_DL_LIBS "")
|
||||
|
||||
set(CMAKE_FIND_LIBRARY_PREFIXES "")
|
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
|
||||
|
||||
# ARTOS does not support shared libs
|
||||
set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE)
|
||||
|
||||
set(CMAKE_C_LINK_SHARED_LIBRARY )
|
||||
set(CMAKE_C_LINK_MODULE_LIBRARY )
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Android-Clang)
|
||||
__android_compiler_clang(ASM)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Android-Clang)
|
||||
__android_compiler_clang(C)
|
||||
@ -0,0 +1,9 @@
|
||||
include(Platform/Android-Clang)
|
||||
__android_compiler_clang(CXX)
|
||||
if(_ANDROID_STL_NOSTDLIBXX)
|
||||
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6)
|
||||
string(APPEND CMAKE_CXX_STANDARD_LIBRARIES " -nostdlib++")
|
||||
else()
|
||||
string(APPEND CMAKE_CXX_STANDARD_LIBRARIES " -nodefaultlibs -lgcc -lc -lm -ldl")
|
||||
endif()
|
||||
endif()
|
||||
@ -0,0 +1,93 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__ANDROID_COMPILER_CLANG)
|
||||
return()
|
||||
endif()
|
||||
set(__ANDROID_COMPILER_CLANG 1)
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/pre/Android-Clang.cmake OPTIONAL)
|
||||
endif()
|
||||
|
||||
# Load flags from NDK. This file may provides the following variables:
|
||||
# _ANDROID_NDK_INIT_CFLAGS
|
||||
# _ANDROID_NDK_INIT_CFLAGS_DEBUG
|
||||
# _ANDROID_NDK_INIT_CFLAGS_RELEASE
|
||||
# _ANDROID_NDK_INIT_LDFLAGS
|
||||
# _ANDROID_NDK_INIT_LDFLAGS_EXE
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/flags.cmake OPTIONAL
|
||||
RESULT_VARIABLE _INCLUDED_FLAGS)
|
||||
endif()
|
||||
|
||||
# Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
|
||||
# implemented in the CMake VS IDE generators. Avoid interfering with
|
||||
# that functionality for now. Later we may try to integrate this.
|
||||
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
|
||||
macro(__android_compiler_clang lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
macro(__android_compiler_clang lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Natively compiling on an Android host doesn't use the NDK cross-compilation
|
||||
# tools.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
|
||||
macro(__android_compiler_clang lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
include(Platform/Android-Common)
|
||||
|
||||
if(_INCLUDED_FLAGS)
|
||||
# NDK provides the flags.
|
||||
set(_ANDROID_ABI_INIT_CFLAGS "${_ANDROID_NDK_INIT_CFLAGS}")
|
||||
set(_ANDROID_ABI_INIT_CFLAGS_DEBUG "${_ANDROID_NDK_INIT_CFLAGS_DEBUG}")
|
||||
set(_ANDROID_ABI_INIT_CFLAGS_RELEASE "${_ANDROID_NDK_INIT_CFLAGS_RELEASE}")
|
||||
set(_ANDROID_ABI_INIT_LDFLAGS "${_ANDROID_NDK_INIT_LDFLAGS}")
|
||||
set(_ANDROID_ABI_INIT_EXE_LDFLAGS "${_ANDROID_NDK_INIT_LDFLAGS_EXE}")
|
||||
else()
|
||||
# The NDK toolchain configuration files at:
|
||||
#
|
||||
# <ndk>/[build/core/]toolchains/*-clang*/setup.mk
|
||||
#
|
||||
# contain logic to set LLVM_TRIPLE for Clang-based toolchains for each target.
|
||||
# We need to produce the same target here to produce compatible binaries.
|
||||
include(Platform/Android/abi-${CMAKE_ANDROID_ARCH_ABI}-Clang)
|
||||
endif()
|
||||
|
||||
macro(__android_compiler_clang lang)
|
||||
if(NOT "x${lang}" STREQUAL "xASM")
|
||||
__android_compiler_common(${lang})
|
||||
endif()
|
||||
if(NOT CMAKE_${lang}_COMPILER_TARGET)
|
||||
set(CMAKE_${lang}_COMPILER_TARGET "${CMAKE_ANDROID_ARCH_LLVM_TRIPLE}")
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
string(APPEND CMAKE_${lang}_COMPILER_TARGET "${CMAKE_SYSTEM_VERSION}")
|
||||
endif()
|
||||
if("${lang}" STREQUAL "CXX")
|
||||
list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "--target=${CMAKE_${lang}_COMPILER_TARGET}")
|
||||
endif()
|
||||
endif()
|
||||
if(CMAKE_GENERATOR MATCHES "Visual Studio")
|
||||
set(_ANDROID_STL_NOSTDLIBXX 1)
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/post/Android-Clang.cmake OPTIONAL)
|
||||
endif()
|
||||
@ -0,0 +1,230 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__ANDROID_COMPILER_COMMON)
|
||||
return()
|
||||
endif()
|
||||
set(__ANDROID_COMPILER_COMMON 1)
|
||||
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
# <ndk>/build/core/definitions.mk
|
||||
|
||||
set(_ANDROID_STL_TYPES
|
||||
none
|
||||
system
|
||||
c++_static
|
||||
c++_shared
|
||||
gabi++_static
|
||||
gabi++_shared
|
||||
gnustl_static
|
||||
gnustl_shared
|
||||
stlport_static
|
||||
stlport_shared
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_STL_TYPE)
|
||||
list(FIND _ANDROID_STL_TYPES "${CMAKE_ANDROID_STL_TYPE}" _ANDROID_STL_TYPE_FOUND)
|
||||
if(_ANDROID_STL_TYPE_FOUND EQUAL -1)
|
||||
string(REPLACE ";" "\n " _msg ";${_ANDROID_STL_TYPES}")
|
||||
message(FATAL_ERROR
|
||||
"The CMAKE_ANDROID_STL_TYPE '${CMAKE_ANDROID_STL_TYPE}' is not one of the allowed values:${_msg}\n"
|
||||
)
|
||||
endif()
|
||||
unset(_ANDROID_STL_TYPE_FOUND)
|
||||
elseif(IS_DIRECTORY ${CMAKE_ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++)
|
||||
set(CMAKE_ANDROID_STL_TYPE "gnustl_static")
|
||||
else()
|
||||
set(CMAKE_ANDROID_STL_TYPE "c++_static")
|
||||
endif()
|
||||
|
||||
unset(_ANDROID_STL_TYPES)
|
||||
|
||||
# Forward Android-specific platform variables to try_compile projects.
|
||||
list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
|
||||
CMAKE_ANDROID_STL_TYPE
|
||||
)
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_STL_TYPE)
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
if(CMAKE_ANDROID_STL_TYPE STREQUAL "system")
|
||||
set(_ANDROID_STL_EXCEPTIONS 0)
|
||||
set(_ANDROID_STL_RTTI 0)
|
||||
macro(__android_stl lang)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libstdc++")
|
||||
if(_ANDROID_STL_EXCEPTIONS OR _ANDROID_STL_RTTI)
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -lc++abi")
|
||||
if(CMAKE_SYSTEM_VERSION LESS 21)
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -landroid_support")
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "c++_static")
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
macro(__android_stl lang)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libc++")
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -static-libstdc++")
|
||||
endmacro()
|
||||
elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "c++_shared")
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
macro(__android_stl lang)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libc++")
|
||||
endmacro()
|
||||
elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "none")
|
||||
set(_ANDROID_STL_RTTI 0)
|
||||
set(_ANDROID_STL_EXCEPTIONS 0)
|
||||
macro(__android_stl lang)
|
||||
# FIXME: Add a way to add project-wide language-specific compile-only flags.
|
||||
set(CMAKE_CXX_COMPILE_OBJECT
|
||||
"<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE> -nostdinc++")
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -nostdlib++")
|
||||
endmacro()
|
||||
else()
|
||||
message(FATAL_ERROR
|
||||
"Android: STL '${CMAKE_ANDROID_STL_TYPE}' not supported by this NDK."
|
||||
)
|
||||
endif()
|
||||
if(DEFINED CMAKE_ANDROID_RTTI)
|
||||
set(_ANDROID_STL_RTTI ${CMAKE_ANDROID_RTTI})
|
||||
endif()
|
||||
if(DEFINED CMAKE_ANDROID_EXCEPTIONS)
|
||||
set(_ANDROID_STL_EXCEPTIONS ${CMAKE_ANDROID_EXCEPTIONS})
|
||||
endif()
|
||||
elseif(CMAKE_ANDROID_NDK)
|
||||
|
||||
macro(__android_stl_inc lang dir req)
|
||||
if(EXISTS "${dir}")
|
||||
list(APPEND CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES "${dir}")
|
||||
elseif(${req})
|
||||
message(FATAL_ERROR
|
||||
"Android: STL '${CMAKE_ANDROID_STL_TYPE}' include directory not found:\n"
|
||||
" ${dir}"
|
||||
)
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(__android_stl_lib lang lib req)
|
||||
if(CMAKE_ANDROID_ARCH_ABI MATCHES "^armeabi" AND NOT CMAKE_ANDROID_ARM_MODE)
|
||||
get_filename_component(_ANDROID_STL_LIBDIR "${lib}" DIRECTORY)
|
||||
get_filename_component(_ANDROID_STL_LIBNAME "${lib}" NAME)
|
||||
set(_ANDROID_STL_LIBTHUMB "${_ANDROID_STL_LIBDIR}/thumb/${_ANDROID_STL_LIBNAME}")
|
||||
unset(_ANDROID_STL_LIBDIR)
|
||||
unset(_ANDROID_STL_LIBNAME)
|
||||
else()
|
||||
set(_ANDROID_STL_LIBTHUMB "")
|
||||
endif()
|
||||
|
||||
if(_ANDROID_STL_LIBTHUMB AND EXISTS "${_ANDROID_STL_LIBTHUMB}")
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " \"${_ANDROID_STL_LIBTHUMB}\"")
|
||||
elseif(EXISTS "${lib}")
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " \"${lib}\"")
|
||||
elseif(${req})
|
||||
message(FATAL_ERROR
|
||||
"Android: STL '${CMAKE_ANDROID_STL_TYPE}' library file not found:\n"
|
||||
" ${lib}"
|
||||
)
|
||||
endif()
|
||||
|
||||
unset(_ANDROID_STL_LIBTHUMB)
|
||||
endmacro()
|
||||
|
||||
include(Platform/Android/ndk-stl-${CMAKE_ANDROID_STL_TYPE})
|
||||
else()
|
||||
macro(__android_stl lang)
|
||||
endmacro()
|
||||
endif()
|
||||
else()
|
||||
macro(__android_stl lang)
|
||||
endmacro()
|
||||
endif()
|
||||
|
||||
# The NDK toolchain configuration files at:
|
||||
#
|
||||
# <ndk>/[build/core/]toolchains/*/setup.mk
|
||||
#
|
||||
# contain logic to set TARGET_CFLAGS and TARGET_LDFLAGS (and debug/release
|
||||
# variants) to tell their build system what flags to pass for each ABI.
|
||||
# We need to produce the same flags here to produce compatible binaries.
|
||||
# We initialize these variables here and set them in the compiler-specific
|
||||
# modules that include this one. Then we use them in the macro below when
|
||||
# it is called.
|
||||
set(_ANDROID_ABI_INIT_CFLAGS "")
|
||||
set(_ANDROID_ABI_INIT_CFLAGS_DEBUG "")
|
||||
set(_ANDROID_ABI_INIT_CFLAGS_RELEASE "")
|
||||
set(_ANDROID_ABI_INIT_LDFLAGS "")
|
||||
set(_ANDROID_ABI_INIT_EXE_LDFLAGS "")
|
||||
|
||||
macro(__android_compiler_common lang)
|
||||
if(_ANDROID_ABI_INIT_CFLAGS)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " ${_ANDROID_ABI_INIT_CFLAGS}")
|
||||
endif()
|
||||
if(_ANDROID_ABI_INIT_CFLAGS_DEBUG)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " ${_ANDROID_ABI_INIT_CFLAGS_DEBUG}")
|
||||
endif()
|
||||
if(_ANDROID_ABI_INIT_CFLAGS_RELEASE)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " ${_ANDROID_ABI_INIT_CFLAGS_RELEASE}")
|
||||
string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " ${_ANDROID_ABI_INIT_CFLAGS_RELEASE}")
|
||||
string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " ${_ANDROID_ABI_INIT_CFLAGS_RELEASE}")
|
||||
endif()
|
||||
if(_ANDROID_ABI_INIT_LDFLAGS)
|
||||
foreach(t EXE SHARED MODULE)
|
||||
string(APPEND CMAKE_${t}_LINKER_FLAGS_INIT " ${_ANDROID_ABI_INIT_LDFLAGS}")
|
||||
endforeach()
|
||||
endif()
|
||||
if(_ANDROID_ABI_INIT_EXE_LDFLAGS)
|
||||
string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ${_ANDROID_ABI_INIT_EXE_LDFLAGS}")
|
||||
endif()
|
||||
|
||||
if(DEFINED _ANDROID_STL_EXCEPTIONS)
|
||||
if(_ANDROID_STL_EXCEPTIONS)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -fexceptions")
|
||||
else()
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -fno-exceptions")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if("x${lang}" STREQUAL "xCXX" AND DEFINED _ANDROID_STL_RTTI)
|
||||
if(_ANDROID_STL_RTTI)
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -frtti")
|
||||
else()
|
||||
string(APPEND CMAKE_${lang}_FLAGS_INIT " -fno-rtti")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if("x${lang}" STREQUAL "xCXX")
|
||||
__android_stl(CXX)
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -latomic -lm")
|
||||
endif()
|
||||
|
||||
# <ndk>/build/core/definitions.mk appends the sysroot's include directory
|
||||
# explicitly at the end of the command-line include path so that it
|
||||
# precedes the toolchain's builtin include directories. This is
|
||||
# necessary so that Android API-version-specific headers are preferred
|
||||
# over those in the toolchain's `include-fixed` directory (which cannot
|
||||
# possibly match all versions).
|
||||
#
|
||||
# Do not do this for a standalone toolchain because it is already
|
||||
# tied to a specific API version.
|
||||
if(CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
if(CMAKE_SYSROOT_COMPILE)
|
||||
set(_cmake_sysroot_compile "${CMAKE_SYSROOT_COMPILE}")
|
||||
else()
|
||||
set(_cmake_sysroot_compile "${CMAKE_SYSROOT}")
|
||||
endif()
|
||||
if(NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS)
|
||||
list(APPEND CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES
|
||||
"${_cmake_sysroot_compile}/usr/include"
|
||||
"${_cmake_sysroot_compile}/usr/include/${CMAKE_ANDROID_ARCH_TRIPLE}"
|
||||
)
|
||||
else()
|
||||
list(APPEND CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES "${_cmake_sysroot_compile}/usr/include")
|
||||
endif()
|
||||
unset(_cmake_sysroot_compile)
|
||||
endif()
|
||||
endmacro()
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Android/Determine-Compiler)
|
||||
__android_determine_compiler(C)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Android/Determine-Compiler)
|
||||
__android_determine_compiler(CXX)
|
||||
@ -0,0 +1,617 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# When CMAKE_SYSTEM_NAME is "Android", CMakeDetermineSystem loads this module.
|
||||
# This module detects platform-wide information about the Android target
|
||||
# in order to store it in "CMakeSystem.cmake".
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/pre/Android-Determine.cmake OPTIONAL)
|
||||
endif()
|
||||
|
||||
# Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
|
||||
# implemented in the CMake VS IDE generators. Avoid interfering with
|
||||
# that functionality for now.
|
||||
if(CMAKE_GENERATOR_PLATFORM STREQUAL "Tegra-Android")
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Natively compiling on an Android host doesn't use the NDK cross-compilation
|
||||
# tools.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
|
||||
return()
|
||||
endif()
|
||||
|
||||
cmake_policy(PUSH)
|
||||
cmake_policy(SET CMP0057 NEW) # if IN_LIST
|
||||
|
||||
# If using Android tools for Visual Studio, compile a sample project to get the
|
||||
# NDK path and set the processor from the generator platform.
|
||||
if(CMAKE_GENERATOR MATCHES "Visual Studio")
|
||||
if(NOT CMAKE_ANDROID_ARCH_ABI AND NOT CMAKE_SYSTEM_PROCESSOR)
|
||||
if(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
|
||||
set(CMAKE_SYSTEM_PROCESSOR "armv7-a")
|
||||
elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64")
|
||||
set(CMAKE_SYSTEM_PROCESSOR "aarch64")
|
||||
elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "x86")
|
||||
set(CMAKE_SYSTEM_PROCESSOR "i686")
|
||||
elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "x64")
|
||||
set(CMAKE_SYSTEM_PROCESSOR "x86_64")
|
||||
else()
|
||||
message(FATAL_ERROR "Unhandled generator platform, please choose ARM, ARM64, x86 or x86_64 using -A")
|
||||
endif()
|
||||
endif()
|
||||
if(NOT CMAKE_ANDROID_NDK)
|
||||
set(vcx_platform ${CMAKE_GENERATOR_PLATFORM})
|
||||
if(CMAKE_GENERATOR MATCHES "Visual Studio 14")
|
||||
set(vcx_revision "2.0")
|
||||
elseif(CMAKE_GENERATOR MATCHES "Visual Studio 1[567]")
|
||||
set(vcx_revision "3.0")
|
||||
else()
|
||||
set(vcx_revision "")
|
||||
endif()
|
||||
configure_file(${CMAKE_ROOT}/Modules/Platform/Android/VCXProjInspect.vcxproj.in
|
||||
${CMAKE_PLATFORM_INFO_DIR}/VCXProjInspect.vcxproj @ONLY)
|
||||
cmake_host_system_information(RESULT _msbuild QUERY VS_MSBUILD_COMMAND) # undocumented query
|
||||
execute_process(
|
||||
COMMAND "${_msbuild}" "VCXProjInspect.vcxproj"
|
||||
"/p:Configuration=Debug" "/p:Platform=${vcx_platform}"
|
||||
WORKING_DIRECTORY ${CMAKE_PLATFORM_INFO_DIR}
|
||||
OUTPUT_VARIABLE VCXPROJ_INSPECT_OUTPUT
|
||||
ERROR_VARIABLE VCXPROJ_INSPECT_OUTPUT
|
||||
RESULT_VARIABLE VCXPROJ_INSPECT_RESULT
|
||||
)
|
||||
unset(_msbuild)
|
||||
if(VCXPROJ_INSPECT_OUTPUT MATCHES "CMAKE_ANDROID_NDK=([^%\r\n]+)[\r\n]")
|
||||
# Strip VS diagnostic output from the end of the line.
|
||||
string(REGEX REPLACE " \\(TaskId:[0-9]*\\)$" "" _ndk "${CMAKE_MATCH_1}")
|
||||
if(EXISTS "${_ndk}")
|
||||
file(TO_CMAKE_PATH "${_ndk}" CMAKE_ANDROID_NDK)
|
||||
endif()
|
||||
endif()
|
||||
if(VCXPROJ_INSPECT_RESULT)
|
||||
message(CONFIGURE_LOG
|
||||
"Determining the Android NDK failed from msbuild failed.
|
||||
The output was:
|
||||
${VCXPROJ_INSPECT_RESULT}
|
||||
${VCXPROJ_INSPECT_OUTPUT}
|
||||
|
||||
")
|
||||
else()
|
||||
message(CONFIGURE_LOG
|
||||
"Determining the Android NDK succeeded.
|
||||
The output was:
|
||||
${VCXPROJ_INSPECT_RESULT}
|
||||
${VCXPROJ_INSPECT_OUTPUT}
|
||||
|
||||
")
|
||||
endif()
|
||||
endif()
|
||||
if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION "clang")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# If the user provided CMAKE_SYSROOT for us, extract information from it.
|
||||
set(_ANDROID_SYSROOT_NDK "")
|
||||
set(_ANDROID_SYSROOT_API "")
|
||||
set(_ANDROID_SYSROOT_ARCH "")
|
||||
set(_ANDROID_SYSROOT_STANDALONE_TOOLCHAIN "")
|
||||
if(CMAKE_SYSROOT)
|
||||
if(NOT IS_DIRECTORY "${CMAKE_SYSROOT}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The specified CMAKE_SYSROOT:\n"
|
||||
" ${CMAKE_SYSROOT}\n"
|
||||
"is not an existing directory."
|
||||
)
|
||||
endif()
|
||||
if(CMAKE_SYSROOT MATCHES "^([^\\\n]*)/platforms/android-([0-9]+)/arch-([a-z0-9_]+)$")
|
||||
set(_ANDROID_SYSROOT_NDK "${CMAKE_MATCH_1}")
|
||||
set(_ANDROID_SYSROOT_API "${CMAKE_MATCH_2}")
|
||||
set(_ANDROID_SYSROOT_ARCH "${CMAKE_MATCH_3}")
|
||||
elseif(CMAKE_SYSROOT MATCHES "^([^\\\n]*)/sysroot$")
|
||||
set(_ANDROID_SYSROOT_STANDALONE_TOOLCHAIN "${CMAKE_MATCH_1}")
|
||||
else()
|
||||
message(FATAL_ERROR
|
||||
"The value of CMAKE_SYSROOT:\n"
|
||||
" ${CMAKE_SYSROOT}\n"
|
||||
"does not match any of the forms:\n"
|
||||
" <ndk>/platforms/android-<api>/arch-<arch>\n"
|
||||
" <standalone-toolchain>/sysroot\n"
|
||||
"where:\n"
|
||||
" <ndk> = Android NDK directory (with forward slashes)\n"
|
||||
" <api> = Android API version number (decimal digits)\n"
|
||||
" <arch> = Android ARCH name (lower case)\n"
|
||||
" <standalone-toolchain> = Path to standalone toolchain prefix\n"
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Find the Android NDK.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
if(NOT IS_DIRECTORY "${CMAKE_ANDROID_NDK}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The NDK root directory specified by CMAKE_ANDROID_NDK:\n"
|
||||
" ${CMAKE_ANDROID_NDK}\n"
|
||||
"does not exist."
|
||||
)
|
||||
endif()
|
||||
elseif(CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
if(NOT IS_DIRECTORY "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The standalone toolchain directory specified by CMAKE_ANDROID_STANDALONE_TOOLCHAIN:\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}\n"
|
||||
"does not exist."
|
||||
)
|
||||
endif()
|
||||
if(NOT EXISTS "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h")
|
||||
message(FATAL_ERROR
|
||||
"Android: The standalone toolchain directory specified by CMAKE_ANDROID_STANDALONE_TOOLCHAIN:\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}\n"
|
||||
"does not contain a sysroot with a known layout. The file:\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h\n"
|
||||
"does not exist."
|
||||
)
|
||||
endif()
|
||||
else()
|
||||
if(IS_DIRECTORY "${_ANDROID_SYSROOT_NDK}")
|
||||
set(CMAKE_ANDROID_NDK "${_ANDROID_SYSROOT_NDK}")
|
||||
elseif(IS_DIRECTORY "${_ANDROID_SYSROOT_STANDALONE_TOOLCHAIN}")
|
||||
set(CMAKE_ANDROID_STANDALONE_TOOLCHAIN "${_ANDROID_SYSROOT_STANDALONE_TOOLCHAIN}")
|
||||
elseif(IS_DIRECTORY "${ANDROID_NDK}")
|
||||
file(TO_CMAKE_PATH "${ANDROID_NDK}" CMAKE_ANDROID_NDK)
|
||||
elseif(IS_DIRECTORY "${ANDROID_STANDALONE_TOOLCHAIN}")
|
||||
file(TO_CMAKE_PATH "${ANDROID_STANDALONE_TOOLCHAIN}" CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
elseif(IS_DIRECTORY "$ENV{ANDROID_NDK_ROOT}")
|
||||
file(TO_CMAKE_PATH "$ENV{ANDROID_NDK_ROOT}" CMAKE_ANDROID_NDK)
|
||||
elseif(IS_DIRECTORY "$ENV{ANDROID_NDK}")
|
||||
file(TO_CMAKE_PATH "$ENV{ANDROID_NDK}" CMAKE_ANDROID_NDK)
|
||||
elseif(IS_DIRECTORY "$ENV{ANDROID_STANDALONE_TOOLCHAIN}")
|
||||
file(TO_CMAKE_PATH "$ENV{ANDROID_STANDALONE_TOOLCHAIN}" CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
endif()
|
||||
# TODO: Search harder for the NDK or standalone toolchain.
|
||||
endif()
|
||||
|
||||
set(_ANDROID_STANDALONE_TOOLCHAIN_API "")
|
||||
if(CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
# Try to read the API level from the toolchain launcher.
|
||||
if(EXISTS "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang")
|
||||
set(_ANDROID_API_LEVEL_CLANG_REGEX "__ANDROID_API__=([0-9]+)")
|
||||
file(STRINGS "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang" _ANDROID_STANDALONE_TOOLCHAIN_BIN_CLANG
|
||||
REGEX "${_ANDROID_API_LEVEL_CLANG_REGEX}" LIMIT_COUNT 1 LIMIT_INPUT 65536)
|
||||
if(_ANDROID_STANDALONE_TOOLCHAIN_BIN_CLANG MATCHES "${_ANDROID_API_LEVEL_CLANG_REGEX}")
|
||||
set(_ANDROID_STANDALONE_TOOLCHAIN_API "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
unset(_ANDROID_STANDALONE_TOOLCHAIN_BIN_CLANG)
|
||||
unset(_ANDROID_API_LEVEL_CLANG_REGEX)
|
||||
endif()
|
||||
if(NOT _ANDROID_STANDALONE_TOOLCHAIN_API)
|
||||
# The compiler launcher does not know __ANDROID_API__. Assume this
|
||||
# is not unified headers and look for it in the api-level.h header.
|
||||
set(_ANDROID_API_LEVEL_H_REGEX "^[\t ]*#[\t ]*define[\t ]+__ANDROID_API__[\t ]+([0-9]+)")
|
||||
file(STRINGS "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h"
|
||||
_ANDROID_API_LEVEL_H_CONTENT REGEX "${_ANDROID_API_LEVEL_H_REGEX}")
|
||||
if(_ANDROID_API_LEVEL_H_CONTENT MATCHES "${_ANDROID_API_LEVEL_H_REGEX}")
|
||||
set(_ANDROID_STANDALONE_TOOLCHAIN_API "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
endif()
|
||||
if(NOT _ANDROID_STANDALONE_TOOLCHAIN_API)
|
||||
message(WARNING
|
||||
"Android: Did not detect API level from\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang\n"
|
||||
"or\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h\n"
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
message(FATAL_ERROR "Android: Neither the NDK or a standalone toolchain was found.")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
# NDK >= 18 has platforms.cmake. It provides:
|
||||
# NDK_MIN_PLATFORM_LEVEL
|
||||
# NDK_MAX_PLATFORM_LEVEL
|
||||
include("${CMAKE_ANDROID_NDK}/build/cmake/platforms.cmake" OPTIONAL RESULT_VARIABLE _INCLUDED_PLATFORMS)
|
||||
# NDK >= 18 has abis.cmake. It provides:
|
||||
# NDK_KNOWN_DEVICE_ABI32S
|
||||
# NDK_KNOWN_DEVICE_ABI64S
|
||||
# NDK >= 23 also provides:
|
||||
# NDK_KNOWN_DEVICE_ABIS
|
||||
# NDK_ABI_<abi>_PROC
|
||||
# NDK_ABI_<abi>_ARCH
|
||||
# NDK_ABI_<abi>_TRIPLE
|
||||
# NDK_ABI_<abi>_LLVM_TRIPLE
|
||||
# NDK_PROC_<processor>_ABI
|
||||
# NDK_ARCH_<arch>_ABI
|
||||
include("${CMAKE_ANDROID_NDK}/build/cmake/abis.cmake" OPTIONAL RESULT_VARIABLE _INCLUDED_ABIS)
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK AND EXISTS "${CMAKE_ANDROID_NDK}/source.properties")
|
||||
# Android NDK revision
|
||||
# Possible formats:
|
||||
# * r16, build 1234: 16.0.1234
|
||||
# * r16b, build 1234: 16.1.1234
|
||||
# * r16 beta 1, build 1234: 16.0.1234-beta1
|
||||
#
|
||||
# Canary builds are not specially marked.
|
||||
file(READ "${CMAKE_ANDROID_NDK}/source.properties" _ANDROID_NDK_SOURCE_PROPERTIES)
|
||||
|
||||
set(_ANDROID_NDK_REVISION_REGEX
|
||||
"^Pkg\\.Desc = Android NDK\nPkg\\.Revision = ([0-9]+)\\.([0-9]+)\\.([0-9]+)(-beta([0-9]+))?")
|
||||
if(NOT _ANDROID_NDK_SOURCE_PROPERTIES MATCHES "${_ANDROID_NDK_REVISION_REGEX}")
|
||||
string(REPLACE "\n" "\n " _ANDROID_NDK_SOURCE_PROPERTIES "${_ANDROID_NDK_SOURCE_PROPERTIES}")
|
||||
message(FATAL_ERROR
|
||||
"Android: Failed to parse NDK revision from:\n"
|
||||
" ${CMAKE_ANDROID_NDK}/source.properties\n"
|
||||
"with content:\n"
|
||||
" ${_ANDROID_NDK_SOURCE_PROPERTIES}")
|
||||
endif()
|
||||
|
||||
set(_ANDROID_NDK_MAJOR "${CMAKE_MATCH_1}")
|
||||
set(_ANDROID_NDK_MINOR "${CMAKE_MATCH_2}")
|
||||
set(_ANDROID_NDK_BUILD "${CMAKE_MATCH_3}")
|
||||
set(_ANDROID_NDK_BETA "${CMAKE_MATCH_5}")
|
||||
if(_ANDROID_NDK_BETA STREQUAL "")
|
||||
set(_ANDROID_NDK_BETA "0")
|
||||
endif()
|
||||
set(CMAKE_ANDROID_NDK_VERSION "${_ANDROID_NDK_MAJOR}.${_ANDROID_NDK_MINOR}")
|
||||
|
||||
unset(_ANDROID_NDK_SOURCE_PROPERTIES)
|
||||
unset(_ANDROID_NDK_REVISION_REGEX)
|
||||
unset(_ANDROID_NDK_MAJOR)
|
||||
unset(_ANDROID_NDK_MINOR)
|
||||
unset(_ANDROID_NDK_BUILD)
|
||||
unset(_ANDROID_NDK_BETA)
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
# Identify the host platform.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
|
||||
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "64")
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "darwin-x86_64")
|
||||
else()
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "darwin-x86")
|
||||
endif()
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
|
||||
if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64")
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "linux-x86_64")
|
||||
else()
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "linux-x86")
|
||||
endif()
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
|
||||
if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "AMD64")
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "windows-x86_64")
|
||||
else()
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "windows")
|
||||
endif()
|
||||
else()
|
||||
message(FATAL_ERROR "Android: Builds hosted on '${CMAKE_HOST_SYSTEM_NAME}' not supported.")
|
||||
endif()
|
||||
|
||||
# Look for a unified toolchain/sysroot provided with the NDK.
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "${CMAKE_ANDROID_NDK}/toolchains/llvm/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}")
|
||||
if(NOT IS_DIRECTORY "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/sysroot")
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "")
|
||||
endif()
|
||||
else()
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "")
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "")
|
||||
endif()
|
||||
|
||||
if(_INCLUDED_ABIS)
|
||||
if(NDK_KNOWN_DEVICE_ABIS)
|
||||
set(_ANDROID_KNOWN_ABIS ${NDK_KNOWN_DEVICE_ABIS})
|
||||
else()
|
||||
set(_ANDROID_KNOWN_ABIS ${NDK_KNOWN_DEVICE_ABI32S} ${NDK_KNOWN_DEVICE_ABI64S})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED NDK_KNOWN_DEVICE_ABIS)
|
||||
# The NDK is not new enough to provide ABI information.
|
||||
# https://developer.android.com/ndk/guides/abis.html
|
||||
|
||||
set(NDK_ABI_arm64-v8a_PROC "aarch64")
|
||||
set(NDK_ABI_arm64-v8a_ARCH "arm64")
|
||||
set(NDK_ABI_arm64-v8a_TRIPLE "aarch64-linux-android")
|
||||
set(NDK_ABI_arm64-v8a_LLVM_TRIPLE "aarch64-none-linux-android")
|
||||
set(NDK_ABI_armeabi-v7a_PROC "armv7-a")
|
||||
set(NDK_ABI_armeabi-v7a_ARCH "arm")
|
||||
set(NDK_ABI_armeabi-v7a_TRIPLE "arm-linux-androideabi")
|
||||
set(NDK_ABI_armeabi-v7a_LLVM_TRIPLE "armv7-none-linux-androideabi")
|
||||
set(NDK_ABI_armeabi-v6_PROC "armv6")
|
||||
set(NDK_ABI_armeabi-v6_ARCH "arm")
|
||||
set(NDK_ABI_armeabi-v6_TRIPLE "arm-linux-androideabi")
|
||||
set(NDK_ABI_armeabi-v6_LLVM_TRIPLE "armv6-none-linux-androideabi")
|
||||
set(NDK_ABI_armeabi_PROC "armv5te")
|
||||
set(NDK_ABI_armeabi_ARCH "arm")
|
||||
set(NDK_ABI_armeabi_TRIPLE "arm-linux-androideabi")
|
||||
set(NDK_ABI_armeabi_LLVM_TRIPLE "armv5te-none-linux-androideabi")
|
||||
set(NDK_ABI_mips_PROC "mips")
|
||||
set(NDK_ABI_mips_ARCH "mips")
|
||||
set(NDK_ABI_mips_TRIPLE "mipsel-linux-android")
|
||||
set(NDK_ABI_mips_LLVM_TRIPLE "mipsel-none-linux-android")
|
||||
set(NDK_ABI_mips64_PROC "mips64")
|
||||
set(NDK_ABI_mips64_ARCH "mips64")
|
||||
set(NDK_ABI_mips64_TRIPLE "mips64el-linux-android")
|
||||
set(NDK_ABI_mips64_LLVM_TRIPLE "mips64el-none-linux-android")
|
||||
set(NDK_ABI_x86_PROC "i686")
|
||||
set(NDK_ABI_x86_ARCH "x86")
|
||||
set(NDK_ABI_x86_TRIPLE "i686-linux-android")
|
||||
set(NDK_ABI_x86_LLVM_TRIPLE "i686-none-linux-android")
|
||||
set(NDK_ABI_x86_64_PROC "x86_64")
|
||||
set(NDK_ABI_x86_64_ARCH "x86_64")
|
||||
set(NDK_ABI_x86_64_TRIPLE "x86_64-linux-android")
|
||||
set(NDK_ABI_x86_64_LLVM_TRIPLE "x86_64-none-linux-android")
|
||||
|
||||
set(NDK_PROC_aarch64_ABI "arm64-v8a")
|
||||
set(NDK_PROC_armv7-a_ABI "armeabi-v7a")
|
||||
set(NDK_PROC_armv6_ABI "armeabi-v6")
|
||||
set(NDK_PROC_armv5te_ABI "armeabi")
|
||||
set(NDK_PROC_i686_ABI "x86")
|
||||
set(NDK_PROC_mips_ABI "mips")
|
||||
set(NDK_PROC_mips64_ABI "mips64")
|
||||
set(NDK_PROC_x86_64_ABI "x86_64")
|
||||
|
||||
set(NDK_ARCH_arm64_ABI "arm64-v8a")
|
||||
set(NDK_ARCH_arm_ABI "armeabi")
|
||||
set(NDK_ARCH_mips_ABI "mips")
|
||||
set(NDK_ARCH_mips64_ABI "mips64")
|
||||
set(NDK_ARCH_x86_ABI "x86")
|
||||
set(NDK_ARCH_x86_64_ABI "x86_64")
|
||||
endif()
|
||||
|
||||
# Validate inputs.
|
||||
if(CMAKE_ANDROID_ARCH_ABI AND NOT DEFINED "NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_PROC")
|
||||
message(FATAL_ERROR "Android: Unknown ABI CMAKE_ANDROID_ARCH_ABI='${CMAKE_ANDROID_ARCH_ABI}'.")
|
||||
endif()
|
||||
if(CMAKE_SYSTEM_PROCESSOR AND NOT DEFINED "NDK_PROC_${CMAKE_SYSTEM_PROCESSOR}_ABI")
|
||||
message(FATAL_ERROR "Android: Unknown processor CMAKE_SYSTEM_PROCESSOR='${CMAKE_SYSTEM_PROCESSOR}'.")
|
||||
endif()
|
||||
if(_ANDROID_SYSROOT_ARCH AND NOT DEFINED "NDK_ARCH_${_ANDROID_SYSROOT_ARCH}_ABI")
|
||||
message(FATAL_ERROR
|
||||
"Android: Unknown architecture '${_ANDROID_SYSROOT_ARCH}' specified in CMAKE_SYSROOT:\n"
|
||||
" ${CMAKE_SYSROOT}"
|
||||
)
|
||||
endif()
|
||||
|
||||
# Select an ABI.
|
||||
if(NOT CMAKE_ANDROID_ARCH_ABI)
|
||||
if(CMAKE_SYSTEM_PROCESSOR)
|
||||
set(CMAKE_ANDROID_ARCH_ABI "${NDK_PROC_${CMAKE_SYSTEM_PROCESSOR}_ABI}")
|
||||
elseif(_ANDROID_SYSROOT_ARCH)
|
||||
set(CMAKE_ANDROID_ARCH_ABI "${NDK_ARCH_${_ANDROID_SYSROOT_ARCH}_ABI}")
|
||||
elseif(_INCLUDED_ABIS)
|
||||
# Default to the oldest ARM ABI.
|
||||
foreach(abi armeabi armeabi-v7a arm64-v8a)
|
||||
if("${abi}" IN_LIST _ANDROID_KNOWN_ABIS)
|
||||
set(CMAKE_ANDROID_ARCH_ABI "${abi}")
|
||||
break()
|
||||
endif()
|
||||
endforeach()
|
||||
if(NOT CMAKE_ANDROID_ARCH_ABI)
|
||||
message(FATAL_ERROR
|
||||
"Android: Can not determine the default ABI. Please set CMAKE_ANDROID_ARCH_ABI."
|
||||
)
|
||||
endif()
|
||||
else()
|
||||
# https://developer.android.com/ndk/guides/application_mk.html
|
||||
# Default is the oldest ARM ABI.
|
||||
|
||||
# Lookup the available ABIs among all toolchains.
|
||||
set(_ANDROID_ABIS "")
|
||||
file(GLOB _ANDROID_CONFIG_MKS
|
||||
"${CMAKE_ANDROID_NDK}/build/core/toolchains/*/config.mk"
|
||||
"${CMAKE_ANDROID_NDK}/toolchains/*/config.mk"
|
||||
)
|
||||
foreach(config_mk IN LISTS _ANDROID_CONFIG_MKS)
|
||||
file(STRINGS "${config_mk}" _ANDROID_TOOL_ABIS REGEX "^TOOLCHAIN_ABIS :=")
|
||||
string(REPLACE "TOOLCHAIN_ABIS :=" "" _ANDROID_TOOL_ABIS "${_ANDROID_TOOL_ABIS}")
|
||||
separate_arguments(_ANDROID_TOOL_ABIS UNIX_COMMAND "${_ANDROID_TOOL_ABIS}")
|
||||
list(APPEND _ANDROID_ABIS ${_ANDROID_TOOL_ABIS})
|
||||
unset(_ANDROID_TOOL_ABIS)
|
||||
endforeach()
|
||||
unset(_ANDROID_CONFIG_MKS)
|
||||
|
||||
# Choose the oldest among the available arm ABIs.
|
||||
if(_ANDROID_ABIS)
|
||||
list(REMOVE_DUPLICATES _ANDROID_ABIS)
|
||||
foreach(abi armeabi armeabi-v7a arm64-v8a)
|
||||
if("${abi}" IN_LIST _ANDROID_ABIS)
|
||||
set(CMAKE_ANDROID_ARCH_ABI "${abi}")
|
||||
break()
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
unset(_ANDROID_ABIS)
|
||||
|
||||
if(NOT CMAKE_ANDROID_ARCH_ABI)
|
||||
set(CMAKE_ANDROID_ARCH_ABI "armeabi")
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
if(_INCLUDED_ABIS AND NOT CMAKE_ANDROID_ARCH_ABI IN_LIST _ANDROID_KNOWN_ABIS)
|
||||
message(FATAL_ERROR
|
||||
"Android: ABI '${CMAKE_ANDROID_ARCH_ABI}' is not supported by the NDK.\n"
|
||||
"Supported ABIS: ${_ANDROID_KNOWN_ABIS}."
|
||||
)
|
||||
endif()
|
||||
set(CMAKE_ANDROID_ARCH "${NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_ARCH}")
|
||||
if(_ANDROID_SYSROOT_ARCH AND NOT "x${_ANDROID_SYSROOT_ARCH}" STREQUAL "x${CMAKE_ANDROID_ARCH}")
|
||||
message(FATAL_ERROR
|
||||
"Android: Architecture '${_ANDROID_SYSROOT_ARCH}' specified in CMAKE_SYSROOT:\n"
|
||||
" ${CMAKE_SYSROOT}\n"
|
||||
"does not match architecture '${CMAKE_ANDROID_ARCH}' for the ABI '${CMAKE_ANDROID_ARCH_ABI}'."
|
||||
)
|
||||
endif()
|
||||
set(CMAKE_ANDROID_ARCH_TRIPLE "${NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_TRIPLE}")
|
||||
set(CMAKE_ANDROID_ARCH_LLVM_TRIPLE
|
||||
"${NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_LLVM_TRIPLE}")
|
||||
|
||||
# Select a processor.
|
||||
if(NOT CMAKE_SYSTEM_PROCESSOR)
|
||||
set(CMAKE_SYSTEM_PROCESSOR "${NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_PROC}")
|
||||
endif()
|
||||
|
||||
# If the user specified both an ABI and a processor then they might not match.
|
||||
if(NOT NDK_ABI_${CMAKE_ANDROID_ARCH_ABI}_PROC STREQUAL CMAKE_SYSTEM_PROCESSOR)
|
||||
message(FATAL_ERROR "Android: The specified CMAKE_ANDROID_ARCH_ABI='${CMAKE_ANDROID_ARCH_ABI}' and CMAKE_SYSTEM_PROCESSOR='${CMAKE_SYSTEM_PROCESSOR}' is not a valid combination.")
|
||||
endif()
|
||||
|
||||
# Select an API.
|
||||
if(CMAKE_SYSTEM_VERSION)
|
||||
set(_ANDROID_API_VAR CMAKE_SYSTEM_VERSION)
|
||||
elseif(CMAKE_ANDROID_API)
|
||||
set(CMAKE_SYSTEM_VERSION "${CMAKE_ANDROID_API}")
|
||||
set(_ANDROID_API_VAR CMAKE_ANDROID_API)
|
||||
elseif(_ANDROID_SYSROOT_API)
|
||||
set(CMAKE_SYSTEM_VERSION "${_ANDROID_SYSROOT_API}")
|
||||
set(_ANDROID_API_VAR CMAKE_SYSROOT)
|
||||
elseif(_ANDROID_STANDALONE_TOOLCHAIN_API)
|
||||
set(CMAKE_SYSTEM_VERSION "${_ANDROID_STANDALONE_TOOLCHAIN_API}")
|
||||
endif()
|
||||
if(CMAKE_SYSTEM_VERSION)
|
||||
if(CMAKE_ANDROID_API AND NOT "x${CMAKE_ANDROID_API}" STREQUAL "x${CMAKE_SYSTEM_VERSION}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The API specified by CMAKE_ANDROID_API='${CMAKE_ANDROID_API}' is not consistent with CMAKE_SYSTEM_VERSION='${CMAKE_SYSTEM_VERSION}'."
|
||||
)
|
||||
endif()
|
||||
if(_ANDROID_SYSROOT_API)
|
||||
foreach(v CMAKE_ANDROID_API CMAKE_SYSTEM_VERSION)
|
||||
if(${v} AND NOT "x${_ANDROID_SYSROOT_API}" STREQUAL "x${${v}}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The API specified by ${v}='${${v}}' is not consistent with CMAKE_SYSROOT:\n"
|
||||
" ${CMAKE_SYSROOT}"
|
||||
)
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
if (_INCLUDED_PLATFORMS)
|
||||
if(CMAKE_SYSTEM_VERSION GREATER NDK_MAX_PLATFORM_LEVEL OR
|
||||
CMAKE_SYSTEM_VERSION LESS NDK_MIN_PLATFORM_LEVEL)
|
||||
message(FATAL_ERROR
|
||||
"Android: The API level ${CMAKE_SYSTEM_VERSION} is not supported by the NDK.\n"
|
||||
"Choose one in the range of [${NDK_MIN_PLATFORM_LEVEL}, ${NDK_MAX_PLATFORM_LEVEL}]."
|
||||
)
|
||||
endif()
|
||||
else()
|
||||
if(NOT IS_DIRECTORY "${CMAKE_ANDROID_NDK}/platforms/android-${CMAKE_SYSTEM_VERSION}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The API specified by ${_ANDROID_API_VAR}='${${_ANDROID_API_VAR}}' does not exist in the NDK. "
|
||||
"The directory:\n"
|
||||
" ${CMAKE_ANDROID_NDK}/platforms/android-${CMAKE_SYSTEM_VERSION}\n"
|
||||
"does not exist."
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
elseif(CMAKE_ANDROID_NDK)
|
||||
if (_INCLUDED_PLATFORMS)
|
||||
set(CMAKE_SYSTEM_VERSION ${NDK_MIN_PLATFORM_LEVEL})
|
||||
# And for LP64 we need to pull up to 21. No diagnostic is provided here because
|
||||
# minSdkVersion < 21 is valid for the project even though it may not be for this
|
||||
# ABI.
|
||||
if(CMAKE_ANDROID_ARCH_ABI MATCHES "64(-v8a)?$" AND CMAKE_SYSTEM_VERSION LESS 21)
|
||||
set(CMAKE_SYSTEM_VERSION 21)
|
||||
endif()
|
||||
else()
|
||||
file(GLOB _ANDROID_APIS_1 RELATIVE "${CMAKE_ANDROID_NDK}/platforms" "${CMAKE_ANDROID_NDK}/platforms/android-[0-9]")
|
||||
file(GLOB _ANDROID_APIS_2 RELATIVE "${CMAKE_ANDROID_NDK}/platforms" "${CMAKE_ANDROID_NDK}/platforms/android-[0-9][0-9]")
|
||||
list(SORT _ANDROID_APIS_1)
|
||||
list(SORT _ANDROID_APIS_2)
|
||||
set(_ANDROID_APIS ${_ANDROID_APIS_1} ${_ANDROID_APIS_2})
|
||||
unset(_ANDROID_APIS_1)
|
||||
unset(_ANDROID_APIS_2)
|
||||
if(_ANDROID_APIS STREQUAL "")
|
||||
message(FATAL_ERROR
|
||||
"Android: No APIs found in the NDK. No\n"
|
||||
" ${CMAKE_ANDROID_NDK}/platforms/android-*\n"
|
||||
"directories exist."
|
||||
)
|
||||
endif()
|
||||
string(REPLACE "android-" "" _ANDROID_APIS "${_ANDROID_APIS}")
|
||||
list(REVERSE _ANDROID_APIS)
|
||||
list(GET _ANDROID_APIS 0 CMAKE_SYSTEM_VERSION)
|
||||
unset(_ANDROID_APIS)
|
||||
endif()
|
||||
endif()
|
||||
if(NOT CMAKE_SYSTEM_VERSION MATCHES "^[0-9]+$")
|
||||
message(FATAL_ERROR "Android: The API specified by CMAKE_SYSTEM_VERSION='${CMAKE_SYSTEM_VERSION}' is not an integer.")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK AND NOT DEFINED CMAKE_ANDROID_NDK_DEPRECATED_HEADERS)
|
||||
if(IS_DIRECTORY "${CMAKE_ANDROID_NDK}/sysroot/usr/include/${CMAKE_ANDROID_ARCH_TRIPLE}")
|
||||
# Unified headers exist so we use them by default.
|
||||
set(CMAKE_ANDROID_NDK_DEPRECATED_HEADERS 0)
|
||||
else()
|
||||
# Unified headers do not exist so use the deprecated headers.
|
||||
set(CMAKE_ANDROID_NDK_DEPRECATED_HEADERS 1)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Save the Android-specific information in CMakeSystem.cmake.
|
||||
set(CMAKE_SYSTEM_CUSTOM_CODE "
|
||||
set(CMAKE_ANDROID_NDK \"${CMAKE_ANDROID_NDK}\")
|
||||
set(CMAKE_ANDROID_STANDALONE_TOOLCHAIN \"${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}\")
|
||||
set(CMAKE_ANDROID_ARCH \"${CMAKE_ANDROID_ARCH}\")
|
||||
set(CMAKE_ANDROID_ARCH_ABI \"${CMAKE_ANDROID_ARCH_ABI}\")
|
||||
")
|
||||
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
string(APPEND CMAKE_SYSTEM_CUSTOM_CODE
|
||||
"set(CMAKE_ANDROID_ARCH_TRIPLE \"${CMAKE_ANDROID_ARCH_TRIPLE}\")\n"
|
||||
"set(CMAKE_ANDROID_ARCH_LLVM_TRIPLE \"${CMAKE_ANDROID_ARCH_LLVM_TRIPLE}\")\n"
|
||||
"set(CMAKE_ANDROID_NDK_VERSION \"${CMAKE_ANDROID_NDK_VERSION}\")\n"
|
||||
"set(CMAKE_ANDROID_NDK_DEPRECATED_HEADERS \"${CMAKE_ANDROID_NDK_DEPRECATED_HEADERS}\")\n"
|
||||
"set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG \"${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}\")\n"
|
||||
"set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED \"${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}\")\n"
|
||||
)
|
||||
endif()
|
||||
|
||||
# Select an ARM variant.
|
||||
if(CMAKE_ANDROID_ARCH_ABI MATCHES "^armeabi")
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
set(CMAKE_ANDROID_ARM_MODE 1)
|
||||
else()
|
||||
set(CMAKE_ANDROID_ARM_MODE 0)
|
||||
endif()
|
||||
string(APPEND CMAKE_SYSTEM_CUSTOM_CODE
|
||||
"set(CMAKE_ANDROID_ARM_MODE \"${CMAKE_ANDROID_ARM_MODE}\")\n"
|
||||
)
|
||||
elseif(DEFINED CMAKE_ANDROID_ARM_MODE)
|
||||
message(FATAL_ERROR "Android: CMAKE_ANDROID_ARM_MODE is set but is valid only for 'armeabi' architectures.")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_ARCH_ABI STREQUAL "armeabi-v7a")
|
||||
if(CMAKE_ANDROID_ARM_NEON)
|
||||
set(CMAKE_ANDROID_ARM_NEON 1)
|
||||
else()
|
||||
set(CMAKE_ANDROID_ARM_NEON 0)
|
||||
endif()
|
||||
string(APPEND CMAKE_SYSTEM_CUSTOM_CODE
|
||||
"set(CMAKE_ANDROID_ARM_NEON \"${CMAKE_ANDROID_ARM_NEON}\")\n"
|
||||
)
|
||||
elseif(DEFINED CMAKE_ANDROID_ARM_NEON)
|
||||
message(FATAL_ERROR "Android: CMAKE_ANDROID_ARM_NEON is set but is valid only for 'armeabi-v7a' architecture.")
|
||||
endif()
|
||||
|
||||
# Report the chosen architecture.
|
||||
message(STATUS "Android: Targeting API '${CMAKE_SYSTEM_VERSION}' with architecture '${CMAKE_ANDROID_ARCH}', ABI '${CMAKE_ANDROID_ARCH_ABI}', and processor '${CMAKE_SYSTEM_PROCESSOR}'")
|
||||
|
||||
cmake_policy(POP)
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/post/Android-Determine.cmake OPTIONAL)
|
||||
endif()
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Android-GNU)
|
||||
__android_compiler_gnu(C)
|
||||
@ -0,0 +1,5 @@
|
||||
include(Platform/Android-GNU)
|
||||
__android_compiler_gnu(CXX)
|
||||
if(_ANDROID_STL_NOSTDLIBXX)
|
||||
string(APPEND CMAKE_CXX_STANDARD_LIBRARIES " -nodefaultlibs -lgcc -lc -lm -ldl")
|
||||
endif()
|
||||
@ -0,0 +1,33 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__ANDROID_COMPILER_GNU)
|
||||
return()
|
||||
endif()
|
||||
set(__ANDROID_COMPILER_GNU 1)
|
||||
|
||||
# Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
|
||||
# implemented in the CMake VS IDE generators. Avoid interfering with
|
||||
# that functionality for now. Later we may try to integrate this.
|
||||
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
|
||||
macro(__android_compiler_gnu lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
macro(__android_compiler_gnu lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
include(Platform/Android-Common)
|
||||
|
||||
include(Platform/Android/abi-${CMAKE_ANDROID_ARCH_ABI}-GNU)
|
||||
|
||||
macro(__android_compiler_gnu lang)
|
||||
__android_compiler_common(${lang})
|
||||
endmacro()
|
||||
@ -0,0 +1,117 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# When CMAKE_SYSTEM_NAME is "Android", CMakeSystemSpecificInitialize loads this
|
||||
# module.
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/pre/Android-Initialize.cmake OPTIONAL)
|
||||
endif()
|
||||
|
||||
include(Platform/Linux-Initialize)
|
||||
unset(LINUX)
|
||||
|
||||
set(ANDROID 1)
|
||||
|
||||
# Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
|
||||
# implemented in the CMake VS IDE generators. Avoid interfering with
|
||||
# that functionality for now.
|
||||
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
return()
|
||||
endif()
|
||||
|
||||
set(CMAKE_BUILD_TYPE_INIT "RelWithDebInfo")
|
||||
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
# Tell CMake not to search host sysroots for headers/libraries.
|
||||
|
||||
# All paths added to CMAKE_SYSTEM_*_PATH below will be rerooted under
|
||||
# CMAKE_FIND_ROOT_PATH. This is set because:
|
||||
# 1. Users may structure their libraries in a way similar to NDK. When they do that,
|
||||
# they can simply append another path to CMAKE_FIND_ROOT_PATH.
|
||||
# 2. CMAKE_FIND_ROOT_PATH must be non-empty for CMAKE_FIND_ROOT_PATH_MODE_* == ONLY
|
||||
# to be meaningful. https://github.com/android-ndk/ndk/issues/890
|
||||
list(APPEND CMAKE_FIND_ROOT_PATH "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/sysroot")
|
||||
|
||||
# Allow users to override these values in case they want more strict behaviors.
|
||||
# For example, they may want to prevent the NDK's libz from being picked up so
|
||||
# they can use their own.
|
||||
# https://github.com/android-ndk/ndk/issues/517
|
||||
if(NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
|
||||
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
|
||||
endif()
|
||||
|
||||
# Allows CMake to find headers in the architecture-specific include directories.
|
||||
set(CMAKE_LIBRARY_ARCHITECTURE "${CMAKE_ANDROID_ARCH_TRIPLE}")
|
||||
|
||||
# Instructs CMake to search the correct API level for libraries.
|
||||
# Besides the paths like <root>/<prefix>/lib/<arch>, cmake also searches <root>/<prefix>.
|
||||
# So we can add the API level specific directory directly.
|
||||
# https://github.com/android/ndk/issues/929
|
||||
list(PREPEND CMAKE_SYSTEM_PREFIX_PATH
|
||||
"/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/${CMAKE_SYSTEM_VERSION}"
|
||||
)
|
||||
|
||||
list(APPEND CMAKE_SYSTEM_PROGRAM_PATH "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin")
|
||||
endif()
|
||||
|
||||
# Skip sysroot selection if the NDK has a unified toolchain.
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Natively compiling on an Android host doesn't use the NDK cross-compilation
|
||||
# tools.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(NOT CMAKE_SYSROOT)
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
set(CMAKE_SYSROOT "${CMAKE_ANDROID_NDK}/platforms/android-${CMAKE_SYSTEM_VERSION}/arch-${CMAKE_ANDROID_ARCH}")
|
||||
if(NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS)
|
||||
set(CMAKE_SYSROOT_COMPILE "${CMAKE_ANDROID_NDK}/sysroot")
|
||||
endif()
|
||||
elseif(CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
set(CMAKE_SYSROOT "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(CMAKE_SYSROOT)
|
||||
if(NOT IS_DIRECTORY "${CMAKE_SYSROOT}")
|
||||
message(FATAL_ERROR
|
||||
"Android: The system root directory needed for the selected Android version and architecture does not exist:\n"
|
||||
" ${CMAKE_SYSROOT}\n"
|
||||
)
|
||||
endif()
|
||||
else()
|
||||
message(FATAL_ERROR
|
||||
"Android: No CMAKE_SYSROOT was selected."
|
||||
)
|
||||
endif()
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/post/Android-Initialize.cmake OPTIONAL)
|
||||
endif()
|
||||
@ -0,0 +1,48 @@
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/pre/Android.cmake OPTIONAL)
|
||||
endif()
|
||||
|
||||
include(Platform/Linux)
|
||||
|
||||
# Natively compiling on an Android host doesn't need these flags to be reset.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
|
||||
return()
|
||||
endif()
|
||||
|
||||
# NDK organizes API level specific libraries in numbered subdirectories. To
|
||||
# avoid incorrect inclusion of libraries below the targeted API level, disable
|
||||
# architecture specific path suffixes by default.
|
||||
set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS OFF)
|
||||
set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS OFF)
|
||||
|
||||
# Conventionally Android does not use versioned soname
|
||||
# But in modern versions it is acceptable
|
||||
if(NOT DEFINED CMAKE_PLATFORM_NO_VERSIONED_SONAME)
|
||||
set(CMAKE_PLATFORM_NO_VERSIONED_SONAME 1)
|
||||
endif()
|
||||
|
||||
# Android reportedly ignores RPATH, and we cannot predict the install
|
||||
# location anyway.
|
||||
set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "")
|
||||
|
||||
# Nsight Tegra Visual Studio Edition takes care of
|
||||
# prefixing library names with '-l'.
|
||||
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
|
||||
set(CMAKE_LINK_LIBRARY_FLAG "")
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
# The NDK legacy toolchain file provides its version number.
|
||||
set(CMAKE_ANDROID_NDK_VERSION ${ANDROID_NDK_MAJOR}.${ANDROID_NDK_MINOR})
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/post/Android.cmake OPTIONAL)
|
||||
endif()
|
||||
@ -0,0 +1,271 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# In Android NDK r19 and above there is a single clang toolchain.
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION STREQUAL "clang")
|
||||
message(FATAL_ERROR
|
||||
"Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}' "
|
||||
"is not supported by this NDK. It must be 'clang' or not set at all."
|
||||
)
|
||||
endif()
|
||||
message(STATUS "Android: Selected unified Clang toolchain")
|
||||
set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "clang")
|
||||
set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang++${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
|
||||
set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_ARCH_TRIPLE}-")
|
||||
return()
|
||||
endif()
|
||||
|
||||
# In Android NDK releases there is build system toolchain selection logic in
|
||||
# these files:
|
||||
#
|
||||
# * <ndk>/build/core/init.mk
|
||||
# * <ndk>/build/core/setup-toolchain.mk
|
||||
# * <ndk>/[build/core/]toolchains/<toolchain>/{config.mk,setup.mk}
|
||||
#
|
||||
# We parse information out of the ``config.mk`` and ``setup.mk`` files below.
|
||||
#
|
||||
# There is also a "toolchains" directory with the prebuilt toolchains themselves:
|
||||
#
|
||||
# * <triple-or-arch>-<gcc-version>/prebuilt/<host>/bin/<triple>-gcc(.exe)?
|
||||
# The gcc compiler to be invoked.
|
||||
#
|
||||
# * llvm*/prebuilt/<host>/bin/clang
|
||||
# The clang compiler to be invoked with flags:
|
||||
# -target <triple>
|
||||
# -gcc-toolchain <ndk>/toolchains/<triple-or-arch>-<gcc-version>
|
||||
|
||||
# Glob available toolchains in the NDK, restricted by any version request.
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION STREQUAL "clang")
|
||||
set(_ANDROID_TOOL_PATTERNS "*-clang" "*-clang[0-9].[0-9]")
|
||||
elseif(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
|
||||
if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION MATCHES "^(clang)?[0-9]\\.[0-9]$")
|
||||
message(FATAL_ERROR
|
||||
"Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}' "
|
||||
"is not one of the allowed forms:\n"
|
||||
" <major>.<minor> = GCC of specified version\n"
|
||||
" clang<major>.<minor> = Clang of specified version\n"
|
||||
" clang = Clang of most recent available version\n"
|
||||
)
|
||||
endif()
|
||||
set(_ANDROID_TOOL_PATTERNS "*-${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}")
|
||||
else()
|
||||
# If we can find any gcc toolchains then use one by default.
|
||||
# Otherwise we look for clang toolchains (e.g. NDK r18+).
|
||||
file(GLOB _ANDROID_CONFIG_MKS_FOR_GCC
|
||||
"${CMAKE_ANDROID_NDK}/build/core/toolchains/*-[0-9].[0-9]/config.mk"
|
||||
"${CMAKE_ANDROID_NDK}/toolchains/*-[0-9].[0-9]/config.mk"
|
||||
)
|
||||
if(_ANDROID_CONFIG_MKS_FOR_GCC)
|
||||
set(_ANDROID_TOOL_PATTERNS "*-[0-9].[0-9]")
|
||||
else()
|
||||
set(_ANDROID_TOOL_PATTERNS "*-clang")
|
||||
endif()
|
||||
unset(_ANDROID_CONFIG_MKS_FOR_GCC)
|
||||
endif()
|
||||
set(_ANDROID_CONFIG_MK_PATTERNS)
|
||||
foreach(base "build/core/toolchains" "toolchains")
|
||||
foreach(pattern IN LISTS _ANDROID_TOOL_PATTERNS)
|
||||
list(APPEND _ANDROID_CONFIG_MK_PATTERNS
|
||||
"${CMAKE_ANDROID_NDK}/${base}/${pattern}/config.mk"
|
||||
)
|
||||
endforeach()
|
||||
endforeach()
|
||||
unset(_ANDROID_TOOL_PATTERNS)
|
||||
file(GLOB _ANDROID_CONFIG_MKS ${_ANDROID_CONFIG_MK_PATTERNS})
|
||||
unset(_ANDROID_CONFIG_MK_PATTERNS)
|
||||
|
||||
# Find the newest toolchain version matching the ABI.
|
||||
set(_ANDROID_TOOL_NAME "")
|
||||
set(_ANDROID_TOOL_VERS 0)
|
||||
set(_ANDROID_TOOL_VERS_NDK "")
|
||||
set(_ANDROID_TOOL_SETUP_MK "")
|
||||
foreach(config_mk IN LISTS _ANDROID_CONFIG_MKS)
|
||||
# Check that the toolchain matches the ABI.
|
||||
file(STRINGS "${config_mk}" _ANDROID_TOOL_ABIS REGEX "^TOOLCHAIN_ABIS :=.* ${CMAKE_ANDROID_ARCH_ABI}( |$)")
|
||||
if(NOT _ANDROID_TOOL_ABIS)
|
||||
continue()
|
||||
endif()
|
||||
unset(_ANDROID_TOOL_ABIS)
|
||||
|
||||
# Check the version.
|
||||
if("${config_mk}" MATCHES [[/([^/]+-((clang)?([0-9]\.[0-9]|)))/config.mk$]])
|
||||
set(_ANDROID_CUR_NAME "${CMAKE_MATCH_1}")
|
||||
set(_ANDROID_CUR_VERS "${CMAKE_MATCH_4}")
|
||||
set(_ANDROID_CUR_VERS_NDK "${CMAKE_MATCH_2}")
|
||||
if(_ANDROID_TOOL_VERS STREQUAL "")
|
||||
# already the latest possible
|
||||
elseif(_ANDROID_CUR_VERS STREQUAL "" OR _ANDROID_CUR_VERS VERSION_GREATER _ANDROID_TOOL_VERS)
|
||||
set(_ANDROID_TOOL_NAME "${_ANDROID_CUR_NAME}")
|
||||
set(_ANDROID_TOOL_VERS "${_ANDROID_CUR_VERS}")
|
||||
set(_ANDROID_TOOL_VERS_NDK "${_ANDROID_CUR_VERS_NDK}")
|
||||
string(REPLACE "/config.mk" "/setup.mk" _ANDROID_TOOL_SETUP_MK "${config_mk}")
|
||||
endif()
|
||||
unset(_ANDROID_CUR_TOOL)
|
||||
unset(_ANDROID_CUR_VERS)
|
||||
unset(_ANDROID_CUR_VERS_NDK)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# Verify that we have a suitable toolchain.
|
||||
if(NOT _ANDROID_TOOL_NAME)
|
||||
if(_ANDROID_CONFIG_MKS)
|
||||
string(REPLACE ";" "\n " _ANDROID_TOOLS_MSG "after considering:;${_ANDROID_CONFIG_MKS}")
|
||||
else()
|
||||
set(_ANDROID_TOOLS_MSG "")
|
||||
endif()
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
|
||||
string(CONCAT _ANDROID_TOOLS_MSG
|
||||
"of the version specified by CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION:\n"
|
||||
" ${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}\n"
|
||||
"${_ANDROID_TOOLS_MSG}")
|
||||
endif()
|
||||
message(FATAL_ERROR
|
||||
"Android: No toolchain for ABI '${CMAKE_ANDROID_ARCH_ABI}' found in the NDK:\n"
|
||||
" ${CMAKE_ANDROID_NDK}\n"
|
||||
"${_ANDROID_TOOLS_MSG}"
|
||||
)
|
||||
endif()
|
||||
unset(_ANDROID_CONFIG_MKS)
|
||||
|
||||
# For clang toolchains we still need to find a gcc toolchain.
|
||||
if(_ANDROID_TOOL_NAME MATCHES "-clang")
|
||||
set(_ANDROID_TOOL_CLANG_NAME "${_ANDROID_TOOL_NAME}")
|
||||
set(_ANDROID_TOOL_CLANG_VERS "${_ANDROID_TOOL_VERS}")
|
||||
set(_ANDROID_TOOL_NAME "")
|
||||
set(_ANDROID_TOOL_VERS "")
|
||||
else()
|
||||
set(_ANDROID_TOOL_CLANG_NAME "")
|
||||
set(_ANDROID_TOOL_CLANG_VERS "")
|
||||
endif()
|
||||
|
||||
# Parse the toolchain setup.mk file to extract information we need.
|
||||
# Their content is not standardized across toolchains or NDK versions,
|
||||
# so we match known cases. Note that the parsing is stateful across
|
||||
# lines because we need to substitute for some Make variable references.
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
|
||||
message(STATUS "loading: ${_ANDROID_TOOL_SETUP_MK}")
|
||||
endif()
|
||||
file(STRINGS "${_ANDROID_TOOL_SETUP_MK}" _ANDROID_TOOL_SETUP REGEX "^(LLVM|TOOLCHAIN)_[A-Z_]+ +:= +.*$")
|
||||
unset(_ANDROID_TOOL_SETUP_MK)
|
||||
set(_ANDROID_TOOL_PREFIX "")
|
||||
set(_ANDROID_TOOL_NAME_ONLY "")
|
||||
set(_ANDROID_TOOL_LLVM_NAME "llvm")
|
||||
set(_ANDROID_TOOL_LLVM_VERS "")
|
||||
foreach(line IN LISTS _ANDROID_TOOL_SETUP)
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
|
||||
message(STATUS "setup.mk: ${line}")
|
||||
endif()
|
||||
|
||||
if(line MATCHES [[^TOOLCHAIN_PREFIX +:= +.*/bin/([^$/ ]*) *$]])
|
||||
# We just matched the toolchain prefix with no Make variable references.
|
||||
set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
|
||||
elseif(_ANDROID_TOOL_CLANG_NAME)
|
||||
# For clang toolchains we need to find more information.
|
||||
if(line MATCHES [[^TOOLCHAIN_VERSION +:= +([0-9.]+) *$]])
|
||||
# We just matched the gcc toolchain version number. Save it for later.
|
||||
set(_ANDROID_TOOL_VERS "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^TOOLCHAIN_NAME +:= +(.*\$\(TOOLCHAIN_VERSION\)) *$]])
|
||||
# We just matched the gcc toolchain name with a version number placeholder, so substitute it.
|
||||
# The gcc toolchain version number will have already been extracted from a TOOLCHAIN_VERSION line.
|
||||
string(REPLACE "$(TOOLCHAIN_VERSION)" "${_ANDROID_TOOL_VERS}" _ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^TOOLCHAIN_NAME +:= +([^$/ ]+) *$]])
|
||||
# We just matched the gcc toolchain name without version number. Save it for later.
|
||||
set(_ANDROID_TOOL_NAME_ONLY "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^TOOLCHAIN_PREFIX +:= +.*/bin/(\$\(TOOLCHAIN_NAME\)-) *$]])
|
||||
# We just matched the toolchain prefix with a name placeholder, so substitute it.
|
||||
# The gcc toolchain name will have already been extracted without version number from a TOOLCHAIN_NAME line.
|
||||
string(REPLACE "$(TOOLCHAIN_NAME)" "${_ANDROID_TOOL_NAME_ONLY}" _ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^LLVM_VERSION +:= +([0-9.]+)$]])
|
||||
# We just matched the llvm prebuilt binary toolchain version number. Save it for later.
|
||||
set(_ANDROID_TOOL_LLVM_VERS "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^LLVM_NAME +:= +(llvm-\$\(LLVM_VERSION\)) *$]])
|
||||
# We just matched the llvm prebuilt binary toolchain directory name with a version number placeholder,
|
||||
# so substitute it. The llvm prebuilt binary toolchain version number will have already been extracted
|
||||
# from a LLVM_VERSION line.
|
||||
string(REPLACE "$(LLVM_VERSION)" "${_ANDROID_TOOL_LLVM_VERS}" _ANDROID_TOOL_LLVM_NAME "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^LLVM_TOOLCHAIN_PREBUILT_ROOT +:= +\$\(call get-toolchain-root.*,([^$ ]+)\) *$]])
|
||||
# We just matched the llvm prebuilt binary toolchain directory name.
|
||||
set(_ANDROID_TOOL_LLVM_NAME "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^TOOLCHAIN_ROOT +:= +\$\(call get-toolchain-root.*,(\$\(TOOLCHAIN_NAME\)-[0-9.]+)\) *$]])
|
||||
# We just matched a placeholder for the name followed by a version number.
|
||||
# The gcc toolchain name will have already been extracted without version number from a TOOLCHAIN_NAME line.
|
||||
# Substitute for the placeholder to get the full gcc toolchain name.
|
||||
string(REPLACE "$(TOOLCHAIN_NAME)" "${_ANDROID_TOOL_NAME_ONLY}" _ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
|
||||
elseif(line MATCHES [[^TOOLCHAIN_ROOT +:= +\$\(call get-toolchain-root.*,([^$ ]+)\) *$]])
|
||||
# We just matched the full gcc toolchain name without placeholder.
|
||||
set(_ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
unset(_ANDROID_TOOL_NAME_ONLY)
|
||||
unset(_ANDROID_TOOL_LLVM_VERS)
|
||||
unset(_ANDROID_TOOL_SETUP)
|
||||
|
||||
# Fall back to parsing the version and prefix from the tool name.
|
||||
if(NOT _ANDROID_TOOL_VERS AND "${_ANDROID_TOOL_NAME}" MATCHES "-([0-9.]+)$")
|
||||
set(_ANDROID_TOOL_VERS "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
if(NOT _ANDROID_TOOL_PREFIX AND "${_ANDROID_TOOL_NAME}" MATCHES "^(.*-)[0-9.]+$")
|
||||
set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
|
||||
# Help CMakeFindBinUtils locate things.
|
||||
set(_CMAKE_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_PREFIX}")
|
||||
|
||||
set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS_NDK}")
|
||||
|
||||
# _ANDROID_TOOL_PREFIX should now match `gcc -dumpmachine`.
|
||||
string(REGEX REPLACE "-$" "" _ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_PREFIX}")
|
||||
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS}")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/${_ANDROID_TOOL_PREFIX}")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
|
||||
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_C_TOOLCHAIN_MACHINE}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "${_ANDROID_TOOL_C_TOOLCHAIN_VERSION}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
|
||||
|
||||
if(_ANDROID_TOOL_CLANG_NAME)
|
||||
message(STATUS "Android: Selected Clang toolchain '${_ANDROID_TOOL_CLANG_NAME}' with GCC toolchain '${_ANDROID_TOOL_NAME}'")
|
||||
set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN ${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG})
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang++${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN}")
|
||||
else()
|
||||
message(STATUS "Android: Selected GCC toolchain '${_ANDROID_TOOL_NAME}'")
|
||||
set(_ANDROID_TOOL_C_COMPILER "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}gcc${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "${_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX}g++${_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
|
||||
message(STATUS "_ANDROID_TOOL_NAME=${_ANDROID_TOOL_NAME}")
|
||||
message(STATUS "_ANDROID_TOOL_VERS=${_ANDROID_TOOL_VERS}")
|
||||
message(STATUS "_ANDROID_TOOL_VERS_NDK=${_ANDROID_TOOL_VERS_NDK}")
|
||||
message(STATUS "_ANDROID_TOOL_PREFIX=${_ANDROID_TOOL_PREFIX}")
|
||||
message(STATUS "_ANDROID_TOOL_CLANG_NAME=${_ANDROID_TOOL_CLANG_NAME}")
|
||||
message(STATUS "_ANDROID_TOOL_CLANG_VERS=${_ANDROID_TOOL_CLANG_VERS}")
|
||||
message(STATUS "_ANDROID_TOOL_LLVM_NAME=${_ANDROID_TOOL_LLVM_NAME}")
|
||||
endif()
|
||||
|
||||
unset(_ANDROID_TOOL_NAME)
|
||||
unset(_ANDROID_TOOL_VERS)
|
||||
unset(_ANDROID_TOOL_VERS_NDK)
|
||||
unset(_ANDROID_TOOL_PREFIX)
|
||||
unset(_ANDROID_TOOL_CLANG_NAME)
|
||||
unset(_ANDROID_TOOL_CLANG_VERS)
|
||||
unset(_ANDROID_TOOL_LLVM_NAME)
|
||||
@ -0,0 +1,65 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
set(_ANDROID_TOOL_C_COMPILER "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "")
|
||||
set(_ANDROID_TOOL_PREFIX "")
|
||||
file(GLOB _gcc "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/*-gcc${_ANDROID_HOST_EXT}")
|
||||
foreach(gcc IN LISTS _gcc)
|
||||
if("${gcc}" MATCHES "/bin/([^/]*)gcc${_ANDROID_HOST_EXT}$")
|
||||
set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
|
||||
break()
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
if(NOT _ANDROID_TOOL_PREFIX)
|
||||
message(FATAL_ERROR
|
||||
"Android: No '*-gcc' compiler found in CMAKE_ANDROID_STANDALONE_TOOLCHAIN:\n"
|
||||
" ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}"
|
||||
)
|
||||
endif()
|
||||
|
||||
# Help CMakeFindBinUtils locate things.
|
||||
set(_CMAKE_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_PREFIX}")
|
||||
|
||||
# _ANDROID_TOOL_PREFIX should now match `gcc -dumpmachine`.
|
||||
string(REGEX REPLACE "-$" "" _ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_PREFIX}")
|
||||
|
||||
execute_process(
|
||||
COMMAND "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/${_ANDROID_TOOL_PREFIX}gcc${_ANDROID_HOST_EXT}" -dumpversion
|
||||
OUTPUT_VARIABLE _gcc_version
|
||||
ERROR_VARIABLE _gcc_error
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE
|
||||
)
|
||||
if(_gcc_version MATCHES "^([0-9]+\\.[0-9]+)")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "${CMAKE_MATCH_1}")
|
||||
else()
|
||||
message(FATAL_ERROR
|
||||
"Android: Failed to extract the standalone toolchain version. The command:\n"
|
||||
" '${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/${_ANDROID_TOOL_PREFIX}gcc${_ANDROID_HOST_EXT}' '-dumpversion'\n"
|
||||
"produced output:\n"
|
||||
" ${_gcc_version}\n"
|
||||
)
|
||||
endif()
|
||||
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/${_ANDROID_TOOL_PREFIX}")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
|
||||
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_C_TOOLCHAIN_MACHINE}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "${_ANDROID_TOOL_C_TOOLCHAIN_VERSION}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
|
||||
|
||||
if(EXISTS "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/bin/clang++${_ANDROID_HOST_EXT}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}")
|
||||
else()
|
||||
set(_ANDROID_TOOL_C_COMPILER "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}gcc${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "${_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX}g++${_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX}")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
endif()
|
||||
|
||||
set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "")
|
||||
@ -0,0 +1,97 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
if(__ANDROID_DETERMINE_COMPILER)
|
||||
return()
|
||||
endif()
|
||||
set(__ANDROID_DETERMINE_COMPILER 1)
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/pre/Determine-Compiler.cmake OPTIONAL)
|
||||
endif()
|
||||
|
||||
# Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
|
||||
# implemented in the CMake VS IDE generators. Avoid interfering with
|
||||
# that functionality for now. Later we may try to integrate this.
|
||||
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
|
||||
macro(__android_determine_compiler lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Commonly used Android toolchain files that pre-date CMake upstream support
|
||||
# set CMAKE_SYSTEM_VERSION to 1. Avoid interfering with them.
|
||||
if(CMAKE_SYSTEM_VERSION EQUAL 1)
|
||||
macro(__android_determine_compiler lang)
|
||||
endmacro()
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Identify the host platform.
|
||||
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
|
||||
set(_ANDROID_HOST_EXT "")
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
|
||||
set(_ANDROID_HOST_EXT "")
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
|
||||
set(_ANDROID_HOST_EXT ".exe")
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
|
||||
# Natively compiling on an Android host doesn't use the NDK cross-compilation
|
||||
# tools.
|
||||
macro(__android_determine_compiler lang)
|
||||
# Do nothing
|
||||
endmacro()
|
||||
if(NOT CMAKE_CXX_COMPILER_NAMES)
|
||||
set(CMAKE_CXX_COMPILER_NAMES c++)
|
||||
endif()
|
||||
return()
|
||||
else()
|
||||
message(FATAL_ERROR "Android: Builds hosted on '${CMAKE_HOST_SYSTEM_NAME}' not supported.")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(Platform/Android/Determine-Compiler-NDK)
|
||||
elseif(CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
|
||||
include(Platform/Android/Determine-Compiler-Standalone)
|
||||
else()
|
||||
set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "")
|
||||
set(_ANDROID_TOOL_C_COMPILER "")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_MACHINE "")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "")
|
||||
set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "")
|
||||
set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER "")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "")
|
||||
set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "")
|
||||
set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "")
|
||||
endif()
|
||||
|
||||
unset(_ANDROID_HOST_EXT)
|
||||
|
||||
macro(__android_determine_compiler lang)
|
||||
if(_ANDROID_TOOL_${lang}_COMPILER)
|
||||
set(CMAKE_${lang}_COMPILER "${_ANDROID_TOOL_${lang}_COMPILER}")
|
||||
set(CMAKE_${lang}_COMPILER_EXTERNAL_TOOLCHAIN "${_ANDROID_TOOL_${lang}_COMPILER_EXTERNAL_TOOLCHAIN}")
|
||||
|
||||
# Save the Android-specific information in CMake${lang}Compiler.cmake.
|
||||
set(CMAKE_${lang}_COMPILER_CUSTOM_CODE "
|
||||
set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION \"${_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION}\")
|
||||
set(CMAKE_${lang}_ANDROID_TOOLCHAIN_MACHINE \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_MACHINE}\")
|
||||
set(CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_VERSION}\")
|
||||
set(CMAKE_${lang}_COMPILER_EXTERNAL_TOOLCHAIN \"${_ANDROID_TOOL_${lang}_COMPILER_EXTERNAL_TOOLCHAIN}\")
|
||||
set(CMAKE_${lang}_ANDROID_TOOLCHAIN_PREFIX \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_PREFIX}\")
|
||||
set(CMAKE_${lang}_ANDROID_TOOLCHAIN_SUFFIX \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_SUFFIX}\")
|
||||
")
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# Include the NDK hook.
|
||||
# It can be used by NDK to inject necessary fixes for an earlier cmake.
|
||||
if(CMAKE_ANDROID_NDK)
|
||||
include(${CMAKE_ANDROID_NDK}/build/cmake/hooks/post/Determine-Compiler.cmake OPTIONAL)
|
||||
endif()
|
||||
@ -0,0 +1,39 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|@vcx_platform@">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>@vcx_platform@</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{14D44772-ECF7-47BD-9E29-BC62FAF940A5}</ProjectGuid>
|
||||
<RootNamespace>VCXProjInspect</RootNamespace>
|
||||
<Keyword>Android</Keyword>
|
||||
<ApplicationType>Android</ApplicationType>
|
||||
<ApplicationTypeRevision>@vcx_revision@</ApplicationTypeRevision>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'" Label="Configuration">
|
||||
<ConfigurationType>DynamicLibrary</ConfigurationType>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<AndroidAPILevel>android-21</AndroidAPILevel>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<PropertyGroup>
|
||||
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
|
||||
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'">false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'">
|
||||
<PostBuildEvent>
|
||||
<Command>%40echo CMAKE_ANDROID_NDK=$(VS_NdkRoot)</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@ -0,0 +1,4 @@
|
||||
# Suppress -Wl,-z,nocopyreloc flag on arm64-v8a
|
||||
set(_ANDROID_ABI_INIT_EXE_LDFLAGS_NO_nocopyreloc 1)
|
||||
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,6 @@
|
||||
# <ndk>/build/core/toolchains/aarch64-linux-android-4.9/setup.mk
|
||||
|
||||
# Suppress -Wl,-z,nocopyreloc flag on arm64-v8a
|
||||
set(_ANDROID_ABI_INIT_EXE_LDFLAGS_NO_nocopyreloc 1)
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1,16 @@
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv5te"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -msoft-float"
|
||||
" -mtune=xscale"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,17 @@
|
||||
# <ndk>/build/core/toolchains/arm-linux-androideabi-4.9/setup.mk
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv5te"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -msoft-float"
|
||||
" -mtune=xscale"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1,15 @@
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv6"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -mfloat-abi=softfp"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,16 @@
|
||||
# <ndk>/build/core/toolchains/arm-linux-androideabi-4.9/setup.mk
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv6"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -mfloat-abi=softfp"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1,25 @@
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv7-a"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_ARM_NEON)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mfpu=neon")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mfpu=vfpv3-d16")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_LDFLAGS
|
||||
" -Wl,--fix-cortex-a8"
|
||||
)
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -mfloat-abi=softfp"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,26 @@
|
||||
# <ndk>/build/core/toolchains/arm-linux-androideabi-4.9/setup.mk
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -march=armv7-a"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_ARM_MODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -marm")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mthumb")
|
||||
endif()
|
||||
|
||||
if(CMAKE_ANDROID_ARM_NEON)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mfpu=neon")
|
||||
else()
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -mfpu=vfpv3-d16")
|
||||
endif()
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -mfloat-abi=softfp"
|
||||
)
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_LDFLAGS
|
||||
" -Wl,--fix-cortex-a8"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1,6 @@
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
#" -Wno-invalid-command-line-argument"
|
||||
#" -Wno-unused-command-line-argument"
|
||||
)
|
||||
|
||||
include(Platform/Android/abi-common)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Android/abi-common)
|
||||
@ -0,0 +1,39 @@
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS
|
||||
" -funwind-tables"
|
||||
" -no-canonical-prefixes"
|
||||
)
|
||||
|
||||
if(CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED AND NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS)
|
||||
string(APPEND _ANDROID_ABI_INIT_CFLAGS " -D__ANDROID_API__=${CMAKE_SYSTEM_VERSION}")
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE
|
||||
AND NOT CMAKE_SYSTEM_VERSION VERSION_LESS 16)
|
||||
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
endif()
|
||||
|
||||
cmake_policy(GET CMP0083 _CMP0083)
|
||||
if(_CMP0083 STREQUAL NEW)
|
||||
# PIE Flags are managed by compiler configuration files
|
||||
if(CMAKE_SYSTEM_VERSION VERSION_GREATER_EQUAL 16)
|
||||
# ensure PIE flags are passed to the linker
|
||||
set(CMAKE_C_LINK_PIE_SUPPORTED YES CACHE INTERNAL "PIE (C)")
|
||||
set(CMAKE_CXX_LINK_PIE_SUPPORTED YES CACHE INTERNAL "PIE (CXX)")
|
||||
if(CMAKE_SYSTEM_VERSION VERSION_GREATER_EQUAL 21)
|
||||
# no PIE executable are no longer supported
|
||||
set(CMAKE_C_LINK_NO_PIE_SUPPORTED NO CACHE INTERNAL "NO_PIE (C)")
|
||||
set(CMAKE_CXX_LINK_NO_PIE_SUPPORTED NO CACHE INTERNAL "NO_PIE (CXX)")
|
||||
endif()
|
||||
endif()
|
||||
else()
|
||||
if(CMAKE_POSITION_INDEPENDENT_CODE)
|
||||
string(APPEND _ANDROID_ABI_INIT_EXE_LDFLAGS " -fPIE -pie")
|
||||
endif()
|
||||
endif()
|
||||
unset(_CMP0083)
|
||||
|
||||
string(APPEND _ANDROID_ABI_INIT_EXE_LDFLAGS " -Wl,--gc-sections")
|
||||
|
||||
if(NOT _ANDROID_ABI_INIT_EXE_LDFLAGS_NO_nocopyreloc)
|
||||
string(APPEND _ANDROID_ABI_INIT_EXE_LDFLAGS " -Wl,-z,nocopyreloc")
|
||||
endif()
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,3 @@
|
||||
# <ndk>/build/core/toolchains/mipsel-linux-android-4.9/setup.mk
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,3 @@
|
||||
# <ndk>/build/core/toolchains/mips64el-linux-android-4.9/setup.mk
|
||||
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,2 @@
|
||||
# <ndk>/build/core/toolchains/x86-4.9/setup.mk
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Android/abi-common-Clang)
|
||||
@ -0,0 +1,2 @@
|
||||
# <ndk>/build/core/toolchains/x86_64-4.9/setup.mk
|
||||
include(Platform/Android/abi-common-GNU)
|
||||
@ -0,0 +1,21 @@
|
||||
# <ndk>/sources/cxx-stl/llvm-libc++/Android.mk
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_NOSTDLIBXX 1)
|
||||
macro(__android_stl_cxx lang filename)
|
||||
# Add the include directory.
|
||||
if(EXISTS "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libcxx/include/cstddef")
|
||||
# r12 and below
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libcxx/include" 1)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/android/support/include" 0)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++abi/libcxxabi/include" 1)
|
||||
else()
|
||||
# r13 and above
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/include" 1)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/android/support/include" 0)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++abi/include" 1)
|
||||
endif()
|
||||
|
||||
# Add the library file.
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${CMAKE_ANDROID_ARCH_ABI}/${filename}" 1)
|
||||
endmacro()
|
||||
@ -0,0 +1,5 @@
|
||||
include(Platform/Android/ndk-stl-c++)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_cxx(${lang} libc++_shared.so)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${CMAKE_ANDROID_ARCH_ABI}/libandroid_support.a" 0)
|
||||
endmacro()
|
||||
@ -0,0 +1,8 @@
|
||||
include(Platform/Android/ndk-stl-c++)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_cxx(${lang} libc++_static.a)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${CMAKE_ANDROID_ARCH_ABI}/libc++abi.a" 0)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${CMAKE_ANDROID_ARCH_ABI}/libandroid_support.a" 0)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libs/${CMAKE_ANDROID_ARCH_ABI}/libunwind.a" 0)
|
||||
string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -latomic") # provided by toolchain
|
||||
endmacro()
|
||||
@ -0,0 +1,8 @@
|
||||
# <ndk>/sources/cxx-stl/gabi++/Android.mk
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_NOSTDLIBXX 1)
|
||||
macro(__android_stl_gabixx lang filename)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gabi++/include" 1)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gabi++/libs/${CMAKE_ANDROID_ARCH_ABI}/${filename}" 1)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-gabi++)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_gabixx(${lang} libgabi++_shared.so)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-gabi++)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_gabixx(${lang} libgabi++_static.a)
|
||||
endmacro()
|
||||
@ -0,0 +1,10 @@
|
||||
# <ndk>/sources/cxx-stl/gnu-libstdc++/Android.mk
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_NOSTDLIBXX 1)
|
||||
macro(__android_stl_gnustl lang filename)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION}/include" 1)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION}/libs/${CMAKE_ANDROID_ARCH_ABI}/include" 1)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION}/include/backward" 1)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION}/libs/${CMAKE_ANDROID_ARCH_ABI}/${filename}" 1)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-gnustl)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_gnustl(${lang} libgnustl_shared.so)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-gnustl)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_gnustl(${lang} libgnustl_static.a)
|
||||
endmacro()
|
||||
@ -0,0 +1,3 @@
|
||||
set(_ANDROID_STL_NOSTDLIBXX 1)
|
||||
macro(__android_stl lang)
|
||||
endmacro()
|
||||
@ -0,0 +1,8 @@
|
||||
# <ndk>/sources/cxx-stl/stlport/Android.mk
|
||||
set(_ANDROID_STL_RTTI 1)
|
||||
set(_ANDROID_STL_EXCEPTIONS 1)
|
||||
set(_ANDROID_STL_NOSTDLIBXX 0)
|
||||
macro(__android_stl_stlport lang filename)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/stlport/stlport" 1)
|
||||
__android_stl_lib(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/stlport/libs/${CMAKE_ANDROID_ARCH_ABI}/${filename}" 1)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-stlport)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_stlport(${lang} libstlport_shared.so)
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Android/ndk-stl-stlport)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_stlport(${lang} libstlport_static.a)
|
||||
endmacro()
|
||||
@ -0,0 +1,7 @@
|
||||
# <ndk>/android-ndk-r11c/sources/cxx-stl/system/Android.mk
|
||||
set(_ANDROID_STL_RTTI 0)
|
||||
set(_ANDROID_STL_EXCEPTIONS 0)
|
||||
set(_ANDROID_STL_NOSTDLIBXX 0)
|
||||
macro(__android_stl lang)
|
||||
__android_stl_inc(${lang} "${CMAKE_ANDROID_NDK}/sources/cxx-stl/system/include" 1)
|
||||
endmacro()
|
||||
@ -0,0 +1,7 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
set(CMAKE_Fortran_VERBOSE_FLAG "-X -v") # Runs gcc under the hood.
|
||||
|
||||
set(CMAKE_Fortran_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
|
||||
set(CMAKE_Fortran_OSX_CURRENT_VERSION_FLAG "-current_version ")
|
||||
@ -0,0 +1 @@
|
||||
set(CMAKE_Swift_SYSROOT_FLAG "-sdk")
|
||||
@ -0,0 +1 @@
|
||||
include(Platform/Apple-Clang-ASM)
|
||||
@ -0,0 +1,6 @@
|
||||
include(Platform/Apple-Clang-C)
|
||||
if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.2)
|
||||
set(CMAKE_C_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
else()
|
||||
unset(CMAKE_C_SYSTEM_FRAMEWORK_SEARCH_FLAG)
|
||||
endif()
|
||||
@ -0,0 +1,6 @@
|
||||
include(Platform/Apple-Clang-CXX)
|
||||
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.2)
|
||||
set(CMAKE_CXX_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
else()
|
||||
unset(CMAKE_CXX_SYSTEM_FRAMEWORK_SEARCH_FLAG)
|
||||
endif()
|
||||
@ -0,0 +1,6 @@
|
||||
include(Platform/Apple-Clang-OBJC)
|
||||
if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 4.2)
|
||||
set(CMAKE_OBJC_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
else()
|
||||
unset(CMAKE_OBJC_SYSTEM_FRAMEWORK_SEARCH_FLAG)
|
||||
endif()
|
||||
@ -0,0 +1,6 @@
|
||||
include(Platform/Apple-Clang-OBJCXX)
|
||||
if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 4.2)
|
||||
set(CMAKE_OBJCXX_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
else()
|
||||
unset(CMAKE_OBJCXX_SYSTEM_FRAMEWORK_SEARCH_FLAG)
|
||||
endif()
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Apple-Clang)
|
||||
__apple_compiler_clang(ASM)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Apple-Clang)
|
||||
__apple_compiler_clang(C)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Apple-Clang)
|
||||
__apple_compiler_clang(CXX)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Apple-Clang)
|
||||
__apple_compiler_clang(OBJC)
|
||||
@ -0,0 +1,2 @@
|
||||
include(Platform/Apple-Clang)
|
||||
__apple_compiler_clang(OBJCXX)
|
||||
@ -0,0 +1,32 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
include_guard()
|
||||
|
||||
macro(__apple_compiler_clang lang)
|
||||
set(CMAKE_${lang}_VERBOSE_FLAG "-v -Wl,-v") # also tell linker to print verbose output
|
||||
set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names")
|
||||
set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS "-bundle -Wl,-headerpad_max_install_names")
|
||||
set(CMAKE_${lang}_SYSROOT_FLAG "-isysroot")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mmacosx-version-min=")
|
||||
if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.2)
|
||||
set(CMAKE_${lang}_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
endif()
|
||||
if(_CMAKE_OSX_SYSROOT_PATH MATCHES "/iPhoneOS")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-miphoneos-version-min=")
|
||||
elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/iPhoneSimulator")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mios-simulator-version-min=")
|
||||
elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/AppleTVOS")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mtvos-version-min=")
|
||||
elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/AppleTVSimulator")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mtvos-simulator-version-min=")
|
||||
elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/WatchOS")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mwatchos-version-min=")
|
||||
elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/WatchSimulator")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mwatchos-simulator-version-min=")
|
||||
else()
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mmacosx-version-min=")
|
||||
endif()
|
||||
endmacro()
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Apple-GNU)
|
||||
__apple_compiler_gnu(C)
|
||||
cmake_gnu_set_sysroot_flag(C)
|
||||
cmake_gnu_set_osx_deployment_target_flag(C)
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Apple-GNU)
|
||||
__apple_compiler_gnu(CXX)
|
||||
cmake_gnu_set_sysroot_flag(CXX)
|
||||
cmake_gnu_set_osx_deployment_target_flag(CXX)
|
||||
@ -0,0 +1,10 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
include(Platform/Apple-GNU)
|
||||
__apple_compiler_gnu(Fortran)
|
||||
cmake_gnu_set_sysroot_flag(Fortran)
|
||||
cmake_gnu_set_osx_deployment_target_flag(Fortran)
|
||||
|
||||
set(CMAKE_Fortran_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
|
||||
set(CMAKE_Fortran_OSX_CURRENT_VERSION_FLAG "-current_version ")
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Apple-GNU)
|
||||
__apple_compiler_gnu(OBJC)
|
||||
cmake_gnu_set_sysroot_flag(OBJC)
|
||||
cmake_gnu_set_osx_deployment_target_flag(OBJC)
|
||||
@ -0,0 +1,4 @@
|
||||
include(Platform/Apple-GNU)
|
||||
__apple_compiler_gnu(OBJCXX)
|
||||
cmake_gnu_set_sysroot_flag(OBJCXX)
|
||||
cmake_gnu_set_osx_deployment_target_flag(OBJCXX)
|
||||
@ -0,0 +1,57 @@
|
||||
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
||||
# file Copyright.txt or https://cmake.org/licensing for details.
|
||||
|
||||
|
||||
# This module is shared by multiple languages; use include blocker.
|
||||
include_guard()
|
||||
|
||||
macro(__apple_compiler_gnu lang)
|
||||
set(CMAKE_${lang}_VERBOSE_FLAG "-v -Wl,-v") # also tell linker to print verbose output
|
||||
# GNU does not have -shared on OS X
|
||||
set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names")
|
||||
set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS "-bundle -Wl,-headerpad_max_install_names")
|
||||
|
||||
if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.3)
|
||||
set(CMAKE_${lang}_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(cmake_gnu_set_sysroot_flag lang)
|
||||
if(NOT DEFINED CMAKE_${lang}_SYSROOT_FLAG)
|
||||
set(_doc "${lang} compiler has -isysroot")
|
||||
message(CHECK_START "Checking whether ${_doc}")
|
||||
execute_process(
|
||||
COMMAND ${CMAKE_${lang}_COMPILER} "-v" "--help"
|
||||
OUTPUT_VARIABLE _gcc_help
|
||||
ERROR_VARIABLE _gcc_help
|
||||
)
|
||||
if("${_gcc_help}" MATCHES "isysroot")
|
||||
message(CHECK_PASS "yes")
|
||||
set(CMAKE_${lang}_SYSROOT_FLAG "-isysroot")
|
||||
else()
|
||||
message(CHECK_FAIL "no")
|
||||
set(CMAKE_${lang}_SYSROOT_FLAG "")
|
||||
endif()
|
||||
set(CMAKE_${lang}_SYSROOT_FLAG_CODE "set(CMAKE_${lang}_SYSROOT_FLAG \"${CMAKE_${lang}_SYSROOT_FLAG}\")")
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(cmake_gnu_set_osx_deployment_target_flag lang)
|
||||
if(NOT DEFINED CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG)
|
||||
set(_doc "${lang} compiler supports OSX deployment target flag")
|
||||
message(CHECK_START "Checking whether ${_doc}")
|
||||
execute_process(
|
||||
COMMAND ${CMAKE_${lang}_COMPILER} "-v" "--help"
|
||||
OUTPUT_VARIABLE _gcc_help
|
||||
ERROR_VARIABLE _gcc_help
|
||||
)
|
||||
if("${_gcc_help}" MATCHES "macosx-version-min")
|
||||
message(CHECK_PASS "yes")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-mmacosx-version-min=")
|
||||
else()
|
||||
message(CHECK_FAIL "no")
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "")
|
||||
endif()
|
||||
set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG_CODE "set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG \"${CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG}\")")
|
||||
endif()
|
||||
endmacro()
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user