From a4a643e64ff575b46c7841d72d6a0b833b24acad Mon Sep 17 00:00:00 2001 From: George Wright Date: Thu, 23 Feb 2012 14:54:49 -0500 Subject: [PATCH] Add support for building for Android (currently only build egltrace.so) MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Signed-off-by: José Fonseca --- CMakeLists.txt | 11 +- INSTALL.markdown | 14 + cmake/.gitignore | 1 + cmake/toolchain/android.toolchain.cmake | 407 ++++++++++++++++++++++++ 4 files changed, 432 insertions(+), 1 deletion(-) create mode 100644 cmake/.gitignore create mode 100644 cmake/toolchain/android.toolchain.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index a9b8f33..596f4b2 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,7 +29,16 @@ set (CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) set (CMAKE_USE_PYTHON_VERSION 2.7 2.6) -find_package (PythonInterp REQUIRED) +if (ANDROID) + set (ENABLE_GUI false) + set (ENABLE_CLI false) +else () + macro (find_host_package) + find_package (${ARGN}) + endmacro() +endif () + +find_host_package (PythonInterp REQUIRED) find_package (Threads) if (ENABLE_GUI) diff --git a/INSTALL.markdown b/INSTALL.markdown index e6cfb61..f395280 100644 --- a/INSTALL.markdown +++ b/INSTALL.markdown @@ -46,6 +46,20 @@ doing: cmake -H. -Bbuild32 -DCMAKE_C_FLAGS=-m32 -DCMAKE_CXX_FLAGS=-m32 -DCMAKE_EXE_LINKER_FLAGS=-m32 -DENABLE_GUI=FALSE make -C build32 glxtrace +Android +------- + +Additional requirements: + +* [Android NDK](http://developer.android.com/sdk/ndk/index.html) + +Build as: + + export ANDROID_NDK=/path/to/your/ndk + cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain/android.toolchain.cmake -DANDROID_API_LEVEL=9 -H. -Bbuild + make -C build + +This will generate a libapitrace.so in your `libs/armeabi-v7a/` directory that can be used. Windows ------- diff --git a/cmake/.gitignore b/cmake/.gitignore new file mode 100644 index 0000000..4d7a231 --- /dev/null +++ b/cmake/.gitignore @@ -0,0 +1 @@ +!*.cmake diff --git a/cmake/toolchain/android.toolchain.cmake b/cmake/toolchain/android.toolchain.cmake new file mode 100644 index 0000000..640f469 --- /dev/null +++ b/cmake/toolchain/android.toolchain.cmake @@ -0,0 +1,407 @@ +# ---------------------------------------------------------------------------- +# Android CMake toolchain file, for use with the ndk r5,r6 +# See home page: http://code.google.com/p/android-cmake/ +# +# Usage Linux: +# $ export ANDROID_NDK=/ +# $ cmake -DCMAKE_TOOLCHAIN_FILE=/android.toolchain.cmake .. +# $ make +# +# Usage Linux (using standalone toolchain): +# $ export ANDROID_NDK_TOOLCHAIN_ROOT=/ +# $ cmake -DCMAKE_TOOLCHAIN_FILE=/android.toolchain.cmake .. +# $ make +# +# Usage Windows: +# You need native port of make to build your project. +# For example this one: http://gnuwin32.sourceforge.net/packages/make.htm +# +# $ SET ANDROID_NDK=C:\\android-ndk-r6 +# $ cmake.exe -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM=C:\\make.exe .. +# $ C:\\make.exe +# +# +# Toolchain options (can be set as cmake parameters: -D=): +# ANDROID_NDK=/opt/android-ndk-r6 - path to NDK root. +# Can be set as environment variable. +# +# ANDROID_NDK_TOOLCHAIN_ROOT=/opt/android-toolchain - path to standalone toolchain. +# Option is not used if full NDK is found. Can be set as environment variable. +# +# ANDROID_API_LEVEL=android-8 - level of android API to use. +# Option is ignored when build uses stanalone toolchain. +# +# ARM_TARGET=armeabi-v7a - type of floating point support. +# Other possible values are: "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3" +# +# FORCE_ARM=false - set true to generate 32-bit ARM instructions instead of Thumb-1. +# +# NO_UNDEFINED=true - set true to show all undefined symbols will as linker errors even if they are not used. +# +# +# Toolcahin will search for NDK/toolchain in following order: +# ANDROID_NDK - cmake parameter +# ANDROID_NDK - environment variable +# ANDROID_NDK - default location +# ANDROID_NDK_TOOLCHAIN_ROOT - cmake parameter +# ANDROID_NDK_TOOLCHAIN_ROOT - environment variable +# ANDROID_NDK_TOOLCHAIN_ROOT - default location +# +# +# What?: +# Make sure to do the following in your scripts: +# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}") +# SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}") +# The flags will be prepopulated with critical flags, so don't loose them. +# +# ANDROID and BUILD_ANDROID will be set to true, you may test these +# variables to make necessary changes. +# +# Also ARMEABI and ARMEABI_V7A will be set true, mutually exclusive. V7A is +# for floating point. NEON option will be set true if fpu is set to neon. +# +# LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where android +# libraries will be installed. +# default is ${CMAKE_SOURCE_DIR} , and the android libs will always be +# under ${LIBRARY_OUTPUT_PATH_ROOT}/libs/armeabi* depending on target. +# this will be convenient for android linking +# +# Base system is Linux, but you may need to change things +# for android compatibility. +# +# +# - initial version December 2010 Ethan Rublee ethan.ruble@gmail.com +# - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com +# [+] added possibility to build with NDK (without standalone toolchain) +# [+] support croos compilation on Windows (native, no cygwin support) +# [+] added compiler option to force "char" type to be signed +# [+] added toolchain option to compile to 32-bit ARM instructions +# [+] added toolchain option to disable SWIG search +# [+] added platform "armeabi-v7a with VFPV3" +# [~] ARM_TARGETS renamed to ARM_TARGET +# - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com +# [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows) +# [~] Fixed bug with ANDROID_API_LEVEL variable +# [~] turn off SWIG search if it is not found first time +# - modified May 2011 Andrey Kamaev andrey.kamaev@itseez.com +# [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL +# [+] ANDROID_API_LEVEL is detected by toolchain if not specified +# [~] added guard to prevent changing of output directories on first cmake pass +# [~] toolchain exits with error if ARM_TARGET is not recognized +# - modified June 2011 Andrey Kamaev andrey.kamaev@itseez.com +# [~] default NDK path is updated for version r5c +# [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET +# [~] toolchain install directory is added to linker paths +# [-] removed SWIG-related stuff from toolchain +# [+] added macro find_host_package, find_host_program to search packages/programs on host system +# [~] fixed path to STL library +# - modified July 2011 Andrey Kamaev andrey.kamaev@itseez.com +# [~] fixed options caching +# [~] search for all supported NDK versions +# [~] allowed spaces in NDK path +# ---------------------------------------------------------------------------- + +# this one is important +set( CMAKE_SYSTEM_NAME Linux ) +#this one not so much +set( CMAKE_SYSTEM_VERSION 1 ) + +set( ANDROID_NDK_DEFAULT_SEARCH_PATH /opt/android-ndk ) +set( ANDROID_NDK_SUPPORTED_VERSIONS -r6 -r5c -r5b -r5 "") +set( ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH /opt/android-toolchain ) +set( TOOL_OS_SUFFIX "" ) + +macro( __TOOLCHAIN_DETECT_API_LEVEL _path ) + SET( _expected ${ARGV1} ) + if( NOT EXISTS ${_path} ) + message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." ) + endif() + SET( API_LEVEL_REGEX "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" ) + FILE( STRINGS ${_path} API_FILE_CONTENT REGEX "${API_LEVEL_REGEX}") + if( NOT API_FILE_CONTENT ) + message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." ) + endif() + string( REGEX REPLACE "${API_LEVEL_REGEX}" "\\1" ANDROID_LEVEL_FOUND "${API_FILE_CONTENT}" ) + if( DEFINED _expected ) + if( NOT ${ANDROID_LEVEL_FOUND} EQUAL ${_expected} ) + message( FATAL_ERROR "Specified Android API level does not match level found. Probably your copy of NDK/toolchain is broken." ) + endif() + endif() + set( ANDROID_API_LEVEL ${ANDROID_LEVEL_FOUND} CACHE STRING "android API level" FORCE ) +endmacro() + +if( NOT DEFINED ANDROID_NDK ) + set( ANDROID_NDK $ENV{ANDROID_NDK} ) +endif() + +if( NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT ) + set( ANDROID_NDK_TOOLCHAIN_ROOT $ENV{ANDROID_NDK_TOOLCHAIN_ROOT} ) +endif() + +#set path for android NDK -- look +if( NOT EXISTS "${ANDROID_NDK}" AND NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT ) + foreach(ndk_version ${ANDROID_NDK_SUPPORTED_VERSIONS}) + if( EXISTS ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} ) + set ( ANDROID_NDK ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} ) + message( STATUS "Using default path for android NDK ${ANDROID_NDK}" ) + message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_NDK" ) + break() + endif() + endforeach() +endif() + +if( EXISTS "${ANDROID_NDK}" ) + set( ANDROID_NDK "${ANDROID_NDK}" CACHE PATH "root of the android ndk" FORCE ) + + if( APPLE ) + set( NDKSYSTEM "darwin-x86" ) + elseif( WIN32 ) + set( NDKSYSTEM "windows" ) + set( TOOL_OS_SUFFIX ".exe" ) + elseif( UNIX ) + set( NDKSYSTEM "linux-x86" ) + else() + message( FATAL_ERROR "Your platform is not supported" ) + endif() + + set( ANDROID_API_LEVEL $ENV{ANDROID_API_LEVEL} ) + string( REGEX REPLACE "[\t ]*android-([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" ) + string( REGEX REPLACE "[\t ]*([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" ) + + set( PossibleAndroidLevels "3;4;5;8;9" ) + set( ANDROID_API_LEVEL ${ANDROID_API_LEVEL} CACHE STRING "android API level" ) + set_property( CACHE ANDROID_API_LEVEL PROPERTY STRINGS ${PossibleAndroidLevels} ) + + if( NOT ANDROID_API_LEVEL GREATER 2 ) + set( ANDROID_API_LEVEL 8) + message( STATUS "Using default android API level android-${ANDROID_API_LEVEL}" ) + message( STATUS " If you prefer to use a different API level, please define the variable: ANDROID_API_LEVEL" ) + endif() + + set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/arm-linux-androideabi-4.4.3/prebuilt/${NDKSYSTEM}" ) + set( ANDROID_NDK_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_API_LEVEL}/arch-arm" ) + + __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" ${ANDROID_API_LEVEL} ) + + #message( STATUS "Using android NDK from ${ANDROID_NDK}" ) + set( BUILD_WITH_ANDROID_NDK True ) +else() + #try to find toolchain + if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" ) + set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" ) + message( STATUS "Using default path for toolchain ${ANDROID_NDK_TOOLCHAIN_ROOT}" ) + message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_NDK_TOOLCHAIN_ROOT" ) + endif() + + set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}" CACHE PATH "root of the Android NDK standalone toolchain" FORCE ) + set( ANDROID_NDK_SYSROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}/sysroot" ) + + if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" ) + message( FATAL_ERROR "neither ${ANDROID_NDK} nor ${ANDROID_NDK_TOOLCHAIN_ROOT} does not exist! + You should either set an environment variable: + export ANDROID_NDK=~/my-android-ndk + or + export ANDROID_NDK_TOOLCHAIN_ROOT=~/my-android-toolchain + or put the toolchain or NDK in the default path: + sudo ln -s ~/my-android-ndk ${ANDROID_NDK_DEFAULT_SEARCH_PATH} + sudo ln -s ~/my-android-toolchain ${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" ) + endif() + + __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" ) + + #message( STATUS "Using android NDK standalone toolchain from ${ANDROID_NDK_TOOLCHAIN_ROOT}" ) + set( BUILD_WITH_ANDROID_NDK_TOOLCHAIN True ) +endif() + +# specify the cross compiler +set( CMAKE_C_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-gcc${TOOL_OS_SUFFIX}" CACHE PATH "gcc" FORCE ) +set( CMAKE_CXX_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-g++${TOOL_OS_SUFFIX}" CACHE PATH "g++" FORCE ) +#there may be a way to make cmake deduce these TODO deduce the rest of the tools +set( CMAKE_AR "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ar${TOOL_OS_SUFFIX}" CACHE PATH "archive" FORCE ) +set( CMAKE_LINKER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ld${TOOL_OS_SUFFIX}" CACHE PATH "linker" FORCE ) +set( CMAKE_NM "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-nm${TOOL_OS_SUFFIX}" CACHE PATH "nm" FORCE ) +set( CMAKE_OBJCOPY "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" FORCE ) +set( CMAKE_OBJDUMP "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" FORCE ) +set( CMAKE_STRIP "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-strip${TOOL_OS_SUFFIX}" CACHE PATH "strip" FORCE ) +set( CMAKE_RANLIB "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ranlib${TOOL_OS_SUFFIX}" CACHE PATH "ranlib" FORCE ) + +#setup build targets, mutually exclusive +set( PossibleArmTargets "armeabi;armeabi-v7a;armeabi-v7a with NEON;armeabi-v7a with VFPV3" ) +#compatibility junk for previous version of toolchain +if( DEFINED ARM_TARGETS AND NOT DEFINED ARM_TARGET ) + set( ARM_TARGET "${ARM_TARGETS}" ) +endif() +IF( NOT ARM_TARGET) + set( ARM_TARGET armeabi-v7a ) +ENDIF() +set( ARM_TARGET "${ARM_TARGET}" CACHE INTERNAL "the arm target for android, recommend armeabi-v7a for floating point support and NEON." ) +set_property( CACHE ARM_TARGET PROPERTY STRINGS ${PossibleArmTargets} ) + +#set these flags for client use +if( ARM_TARGET STREQUAL "armeabi" ) + set( ARMEABI true ) + set( ARMEABI_NDK_NAME "armeabi" ) + set( NEON false ) + set( CMAKE_SYSTEM_PROCESSOR "armv5te" ) +else() + if( ARM_TARGET STREQUAL "armeabi-v7a with NEON" ) + set( NEON true ) + set( VFPV3 true ) + elseif( ARM_TARGET STREQUAL "armeabi-v7a with VFPV3" ) + set( VFPV3 true ) + elseif( NOT ARM_TARGET STREQUAL "armeabi-v7a") + message( FATAL_ERROR "Unsupported ARM_TARGET=${ARM_TARGET} is specified. +Supported values are: \"armeabi\", \"armeabi-v7a\", \"armeabi-v7a with NEON\", \"armeabi-v7a with VFPV3\" +" ) + endif() + set( ARMEABI_V7A true ) + set( ARMEABI_NDK_NAME "armeabi-v7a" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) +endif() + +#setup output directories +set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" ) + +SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS OFF CACHE BOOL "") +if( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ) + if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" ) + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ARMEABI_NDK_NAME}" CACHE PATH "Output directory for applications") + else() + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications") + endif() + set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ARMEABI_NDK_NAME}" CACHE PATH "path for android libs") + set( CMAKE_INSTALL_PREFIX "${ANDROID_NDK_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" ) +endif() +SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ON CACHE INTERNAL "" FORCE) + +# where is the target environment +set( CMAKE_FIND_ROOT_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin" "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi" "${ANDROID_NDK_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" ) + +if( BUILD_WITH_ANDROID_NDK ) + set( STL_PATH "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" ) + set( STL_LIBRARIES_PATH "${STL_PATH}/libs/${ARMEABI_NDK_NAME}" ) + include_directories(SYSTEM "${STL_PATH}/include" "${STL_LIBRARIES_PATH}/include" ) +# if ( NOT ARMEABI AND NOT FORCE_ARM ) +# set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" ) +# endif() +endif() + +if( BUILD_WITH_ANDROID_NDK_TOOLCHAIN ) + set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib" ) + if( NOT ARMEABI ) + set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/${CMAKE_SYSTEM_PROCESSOR}" ) + endif() + if( NOT FORCE_ARM ) + set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/thumb" ) + endif() + #for some reason this is needed? TODO figure out why... + include_directories(SYSTEM "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi" ) +endif() + +# only search for libraries and includes in the ndk toolchain +set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) + +set( CMAKE_CXX_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" ) +set( CMAKE_C_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" ) + +set( FORCE_ARM OFF CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" ) +if( NOT FORCE_ARM ) + #It is recommended to use the -mthumb compiler flag to force the generation + #of 16-bit Thumb-1 instructions (the default being 32-bit ARM ones). + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mthumb" ) + set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthumb" ) +else() + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -marm" ) + set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -marm" ) +endif() + +if( BUILD_WITH_ANDROID_NDK ) + set( CMAKE_CXX_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_CXX_FLAGS}" ) + set( CMAKE_C_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_C_FLAGS}" ) + + # workaround for ugly cmake bug - compiler identification replaces all spaces (and somethimes " !!!) in compiler flags with ; symbol + # as result identification fails if ANDROID_NDK_SYSROOT contain spaces + include(CMakeForceCompiler) + CMAKE_FORCE_C_COMPILER("${CMAKE_C_COMPILER}" GNU) + CMAKE_FORCE_CXX_COMPILER("${CMAKE_CXX_COMPILER}" GNU) +endif() + +if( ARMEABI_V7A ) + #these are required flags for android armv7-a + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" ) + set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfloat-abi=softfp" ) + if( NEON ) + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon" ) + set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon" ) + elseif( VFPV3 ) + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfpv3" ) + set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfpv3" ) + endif() +endif() + +set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags" ) +set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags" ) + +#-Wl,-L${LIBCPP_LINK_DIR},-lstdc++,-lsupc++ +#-L${LIBCPP_LINK_DIR} -lstdc++ -lsupc++ +#Also, this is *required* to use the following linker flags that routes around +#a CPU bug in some Cortex-A8 implementations: +set( LINKER_FLAGS "-Wl,--fix-cortex-a8 -L\"${STL_LIBRARIES_PATH}\" -L\"${CMAKE_INSTALL_PREFIX}/libs/${ARMEABI_NDK_NAME}\" -lstdc++ -lsupc++ " ) + +set( NO_UNDEFINED ON CACHE BOOL "Don't all undefined symbols" ) +if( NO_UNDEFINED ) + set( LINKER_FLAGS "-Wl,--no-undefined ${LINKER_FLAGS}" ) +endif() + +set( CMAKE_SHARED_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE ) +set( CMAKE_MODULE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE ) +set( CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE ) + +#set these global flags for cmake client scripts to change behavior +set( ANDROID True ) +set( BUILD_ANDROID True ) + +#macro to find packages on the host OS +macro(find_host_package) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_package( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() +#macro to find programs on the host OS +macro(find_host_program) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_program( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() + +MARK_AS_ADVANCED(FORCE_ARM NO_UNDEFINED) -- 2.43.0