git.cworth.org Git - apitrace/blob - cmake/toolchain/android.toolchain.cmake

   1 # ----------------------------------------------------------------------------
   2 #  Android CMake toolchain file, for use with the ndk r5,r6
   3 #  See home page: http://code.google.com/p/android-cmake/
   4 #
   5 #  Usage Linux:
   6 #   $ export ANDROID_NDK=/<absolute path to NDK>
   7 #   $ cmake -DCMAKE_TOOLCHAIN_FILE=<path to this file>/android.toolchain.cmake ..
   8 #   $ make
   9 #
  10 #  Usage Linux (using standalone toolchain):
  11 #   $ export ANDROID_NDK_TOOLCHAIN_ROOT=/<absolute path to standalone toolchain>
  12 #   $ cmake -DCMAKE_TOOLCHAIN_FILE=<path to this file>/android.toolchain.cmake ..
  13 #   $ make
  14 #
  15 #  Usage Windows:
  16 #     You need native port of make to build your project.
  17 #     For example this one: http://gnuwin32.sourceforge.net/packages/make.htm
  18 #
  19 #   $ SET ANDROID_NDK=C:\<absolute path to NDK>\android-ndk-r6
  20 #   $ cmake.exe -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=<path to this file>\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM=C:\<absolute path to make>\make.exe ..
  21 #   $ C:\<absolute path to make>\make.exe
  22 #
  23 #
  24 #  Toolchain options (can be set as cmake parameters: -D<option_name>=<value>):
  25 #    ANDROID_NDK=/opt/android-ndk-r6 - path to NDK root.
  26 #      Can be set as environment variable.
  27 #
  28 #    ANDROID_NDK_TOOLCHAIN_ROOT=/opt/android-toolchain - path to standalone toolchain.
  29 #      Option is not used if full NDK is found. Can be set as environment variable.
  30 #
  31 #    ANDROID_API_LEVEL=android-8 - level of android API to use.
  32 #      Option is ignored when build uses stanalone toolchain.
  33 #
  34 #    ARM_TARGET=armeabi-v7a - type of floating point support.
  35 #      Other possible values are: "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3"
  36 #
  37 #    FORCE_ARM=false - set true to generate 32-bit ARM instructions instead of Thumb-1.
  38 #
  39 #    NO_UNDEFINED=true - set true to show all undefined symbols will as linker errors even if they are not used.
  40 #
  41 #
  42 #  Toolcahin will search for NDK/toolchain in following order:
  43 #    ANDROID_NDK - cmake parameter
  44 #    ANDROID_NDK - environment variable
  45 #    ANDROID_NDK - default location
  46 #    ANDROID_NDK_TOOLCHAIN_ROOT - cmake parameter
  47 #    ANDROID_NDK_TOOLCHAIN_ROOT - environment variable
  48 #    ANDROID_NDK_TOOLCHAIN_ROOT - default location
  49 #
  50 #
  51 #  What?:
  52 #     Make sure to do the following in your scripts:
  53 #       SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}")
  54 #       SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  ${my_cxx_flags}")
  55 #       The flags will be prepopulated with critical flags, so don't loose them.
  56 #
  57 #     ANDROID and BUILD_ANDROID will be set to true, you may test these
  58 #     variables to make necessary changes.
  59 #
  60 #     Also ARMEABI and ARMEABI_V7A will be set true, mutually exclusive. V7A is
  61 #     for floating point. NEON option will be set true if fpu is set to neon.
  62 #
  63 #     LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where android
  64 #     libraries will be installed.
  65 #        default is ${CMAKE_SOURCE_DIR} , and the android libs will always be
  66 #        under ${LIBRARY_OUTPUT_PATH_ROOT}/libs/armeabi* depending on target.
  67 #        this will be convenient for android linking
  68 #
  69 #     Base system is Linux, but you may need to change things
  70 #     for android compatibility.
  71 #
  72 #
  73 #   - initial version December 2010 Ethan Rublee ethan.ruble@gmail.com
  74 #   - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com
  75 #     [+] added possibility to build with NDK (without standalone toolchain)
  76 #     [+] support croos compilation on Windows (native, no cygwin support)
  77 #     [+] added compiler option to force "char" type to be signed
  78 #     [+] added toolchain option to compile to 32-bit ARM instructions
  79 #     [+] added toolchain option to disable SWIG search
  80 #     [+] added platform "armeabi-v7a with VFPV3"
  81 #     [~] ARM_TARGETS renamed to ARM_TARGET
  82 #   - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com
  83 #     [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)
  84 #     [~] Fixed bug with ANDROID_API_LEVEL variable
  85 #     [~] turn off SWIG search if it is not found first time
  86 #   - modified May 2011 Andrey Kamaev andrey.kamaev@itseez.com
  87 #     [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL
  88 #     [+] ANDROID_API_LEVEL is detected by toolchain if not specified
  89 #     [~] added guard to prevent changing of output directories on first cmake pass
  90 #     [~] toolchain exits with error if ARM_TARGET is not recognized
  91 #   - modified June 2011 Andrey Kamaev andrey.kamaev@itseez.com
  92 #     [~] default NDK path is updated for version r5c
  93 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
  94 #     [~] toolchain install directory is added to linker paths
  95 #     [-] removed SWIG-related stuff from toolchain
  96 #     [+] added macro find_host_package, find_host_program to search packages/programs on host system
  97 #     [~] fixed path to STL library
  98 #   - modified July 2011 Andrey Kamaev andrey.kamaev@itseez.com
  99 #     [~] fixed options caching
 100 #     [~] search for all supported NDK versions
 101 #     [~] allowed spaces in NDK path
 102 # ----------------------------------------------------------------------------
 103
 104 # this one is important
 105 set( CMAKE_SYSTEM_NAME Linux )
 106 #this one not so much
 107 set( CMAKE_SYSTEM_VERSION 1 )
 108
 109 set( ANDROID_NDK_DEFAULT_SEARCH_PATH /opt/android-ndk )
 110 set( ANDROID_NDK_SUPPORTED_VERSIONS -r6 -r5c -r5b -r5 "")
 111 set( ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH /opt/android-toolchain )
 112 set( TOOL_OS_SUFFIX "" )
 113
 114 macro( __TOOLCHAIN_DETECT_API_LEVEL _path )
 115  SET( _expected ${ARGV1} )
 116  if( NOT EXISTS ${_path} )
 117   message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
 118  endif()
 119  SET( API_LEVEL_REGEX "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" )
 120  FILE( STRINGS ${_path} API_FILE_CONTENT REGEX "${API_LEVEL_REGEX}")
 121  if( NOT API_FILE_CONTENT )
 122   message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
 123  endif()
 124  string( REGEX REPLACE "${API_LEVEL_REGEX}" "\\1" ANDROID_LEVEL_FOUND "${API_FILE_CONTENT}" )
 125  if( DEFINED _expected )
 126   if( NOT ${ANDROID_LEVEL_FOUND} EQUAL ${_expected} )
 127    message( FATAL_ERROR "Specified Android API level does not match level found. Probably your copy of NDK/toolchain is broken." )
 128   endif()
 129  endif()
 130  set( ANDROID_API_LEVEL ${ANDROID_LEVEL_FOUND} CACHE STRING "android API level" FORCE )
 131 endmacro()
 132
 133 if( NOT DEFINED ANDROID_NDK )
 134  set( ANDROID_NDK $ENV{ANDROID_NDK} )
 135 endif()
 136
 137 if( NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
 138  set( ANDROID_NDK_TOOLCHAIN_ROOT $ENV{ANDROID_NDK_TOOLCHAIN_ROOT} )
 139 endif()
 140
 141 #set path for android NDK -- look
 142 if( NOT EXISTS "${ANDROID_NDK}" AND NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
 143  foreach(ndk_version ${ANDROID_NDK_SUPPORTED_VERSIONS})
 144   if( EXISTS ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
 145    set ( ANDROID_NDK ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
 146    message( STATUS "Using default path for android NDK ${ANDROID_NDK}" )
 147    message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_NDK" )
 148    break()
 149   endif()
 150  endforeach()
 151 endif()
 152
 153 if( EXISTS "${ANDROID_NDK}" )
 154  set( ANDROID_NDK "${ANDROID_NDK}" CACHE PATH "root of the android ndk" FORCE )
 155
 156  if( APPLE )
 157   set( NDKSYSTEM "darwin-x86" )
 158  elseif( WIN32 )
 159   set( NDKSYSTEM "windows" )
 160   set( TOOL_OS_SUFFIX ".exe" )
 161  elseif( UNIX )
 162   set( NDKSYSTEM "linux-x86" )
 163  else()
 164   message( FATAL_ERROR "Your platform is not supported" )
 165  endif()
 166
 167  set( ANDROID_API_LEVEL $ENV{ANDROID_API_LEVEL} )
 168  string( REGEX REPLACE "[\t ]*android-([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" )
 169  string( REGEX REPLACE "[\t ]*([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" )
 170
 171  set( PossibleAndroidLevels "3;4;5;8;9" )
 172  set( ANDROID_API_LEVEL ${ANDROID_API_LEVEL} CACHE STRING "android API level" )
 173  set_property( CACHE ANDROID_API_LEVEL PROPERTY STRINGS ${PossibleAndroidLevels} )
 174
 175  if( NOT ANDROID_API_LEVEL GREATER 2 )
 176   set( ANDROID_API_LEVEL 8)
 177   message( STATUS "Using default android API level android-${ANDROID_API_LEVEL}" )
 178   message( STATUS "  If you prefer to use a different API level, please define the variable: ANDROID_API_LEVEL" )
 179  endif()
 180
 181  set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/arm-linux-androideabi-4.4.3/prebuilt/${NDKSYSTEM}" )
 182  set( ANDROID_NDK_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_API_LEVEL}/arch-arm" )
 183
 184  __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" ${ANDROID_API_LEVEL} )
 185
 186  #message( STATUS "Using android NDK from ${ANDROID_NDK}" )
 187  set( BUILD_WITH_ANDROID_NDK True )
 188 else()
 189  #try to find toolchain
 190  if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
 191   set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" )
 192   message( STATUS "Using default path for toolchain ${ANDROID_NDK_TOOLCHAIN_ROOT}" )
 193   message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_NDK_TOOLCHAIN_ROOT" )
 194  endif()
 195
 196  set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}" CACHE PATH "root of the Android NDK standalone toolchain" FORCE )
 197  set( ANDROID_NDK_SYSROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}/sysroot" )
 198
 199  if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
 200   message( FATAL_ERROR "neither ${ANDROID_NDK} nor ${ANDROID_NDK_TOOLCHAIN_ROOT} does not exist!
 201     You should either set an environment variable:
 202       export ANDROID_NDK=~/my-android-ndk
 203     or
 204       export ANDROID_NDK_TOOLCHAIN_ROOT=~/my-android-toolchain
 205     or put the toolchain or NDK in the default path:
 206       sudo ln -s ~/my-android-ndk ${ANDROID_NDK_DEFAULT_SEARCH_PATH}
 207       sudo ln -s ~/my-android-toolchain ${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" )
 208  endif()
 209
 210  __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" )
 211
 212  #message( STATUS "Using android NDK standalone toolchain from ${ANDROID_NDK_TOOLCHAIN_ROOT}" )
 213  set( BUILD_WITH_ANDROID_NDK_TOOLCHAIN True )
 214 endif()
 215
 216 # specify the cross compiler
 217 set( CMAKE_C_COMPILER   "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "gcc" FORCE )
 218 set( CMAKE_CXX_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-g++${TOOL_OS_SUFFIX}"     CACHE PATH "g++" FORCE )
 219 #there may be a way to make cmake deduce these TODO deduce the rest of the tools
 220 set( CMAKE_AR           "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ar${TOOL_OS_SUFFIX}"      CACHE PATH "archive" FORCE )
 221 set( CMAKE_LINKER       "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ld${TOOL_OS_SUFFIX}"      CACHE PATH "linker" FORCE )
 222 set( CMAKE_NM           "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-nm${TOOL_OS_SUFFIX}"      CACHE PATH "nm" FORCE )
 223 set( CMAKE_OBJCOPY      "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" FORCE )
 224 set( CMAKE_OBJDUMP      "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" FORCE )
 225 set( CMAKE_STRIP        "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" FORCE )
 226 set( CMAKE_RANLIB       "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ranlib${TOOL_OS_SUFFIX}"  CACHE PATH "ranlib" FORCE )
 227
 228 #setup build targets, mutually exclusive
 229 set( PossibleArmTargets "armeabi;armeabi-v7a;armeabi-v7a with NEON;armeabi-v7a with VFPV3" )
 230 #compatibility junk for previous version of toolchain
 231 if( DEFINED ARM_TARGETS AND NOT DEFINED ARM_TARGET )
 232  set( ARM_TARGET "${ARM_TARGETS}" )
 233 endif()
 234 IF( NOT ARM_TARGET)
 235  set( ARM_TARGET armeabi-v7a )
 236 ENDIF()
 237 set( ARM_TARGET "${ARM_TARGET}" CACHE INTERNAL "the arm target for android, recommend armeabi-v7a for floating point support and NEON." )
 238 set_property( CACHE ARM_TARGET PROPERTY STRINGS ${PossibleArmTargets} )
 239
 240 #set these flags for client use
 241 if( ARM_TARGET STREQUAL "armeabi" )
 242  set( ARMEABI true )
 243  set( ARMEABI_NDK_NAME "armeabi" )
 244  set( NEON false )
 245  set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
 246 else()
 247  if( ARM_TARGET STREQUAL "armeabi-v7a with NEON" )
 248   set( NEON true )
 249   set( VFPV3 true )
 250  elseif( ARM_TARGET STREQUAL "armeabi-v7a with VFPV3" )
 251   set( VFPV3 true )
 252  elseif( NOT ARM_TARGET STREQUAL "armeabi-v7a")
 253   message( FATAL_ERROR "Unsupported ARM_TARGET=${ARM_TARGET} is specified.
 254 Supported values are: \"armeabi\", \"armeabi-v7a\", \"armeabi-v7a with NEON\", \"armeabi-v7a with VFPV3\"
 255 " )
 256  endif()
 257  set( ARMEABI_V7A true )
 258  set( ARMEABI_NDK_NAME "armeabi-v7a" )
 259  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 260 endif()
 261
 262 #setup output directories
 263 set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
 264
 265 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS OFF CACHE BOOL "")
 266 if( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS )
 267  if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
 268   set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ARMEABI_NDK_NAME}" CACHE PATH "Output directory for applications")
 269  else()
 270   set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications")
 271  endif()
 272  set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ARMEABI_NDK_NAME}" CACHE PATH "path for android libs")
 273  set( CMAKE_INSTALL_PREFIX "${ANDROID_NDK_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
 274 endif()
 275 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ON CACHE INTERNAL "" FORCE)
 276
 277 # where is the target environment
 278 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" )
 279
 280 if( BUILD_WITH_ANDROID_NDK )
 281  set( STL_PATH "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
 282  set( STL_LIBRARIES_PATH "${STL_PATH}/libs/${ARMEABI_NDK_NAME}" )
 283  include_directories(SYSTEM "${STL_PATH}/include" "${STL_LIBRARIES_PATH}/include" )
 284 # if ( NOT ARMEABI AND NOT FORCE_ARM )
 285 #  set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
 286 # endif()
 287 endif()
 288
 289 if( BUILD_WITH_ANDROID_NDK_TOOLCHAIN )
 290  set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib" )
 291  if( NOT ARMEABI )
 292   set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/${CMAKE_SYSTEM_PROCESSOR}" )
 293  endif()
 294  if( NOT FORCE_ARM )
 295   set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/thumb" )
 296  endif()
 297  #for some reason this is needed? TODO figure out why...
 298  include_directories(SYSTEM "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi" )
 299 endif()
 300
 301 # only search for libraries and includes in the ndk toolchain
 302 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 303 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 304 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 305
 306 set( CMAKE_CXX_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" )
 307 set( CMAKE_C_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" )
 308
 309 set( FORCE_ARM OFF CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" )
 310 if( NOT FORCE_ARM )
 311  #It is recommended to use the -mthumb compiler flag to force the generation
 312  #of 16-bit Thumb-1 instructions (the default being 32-bit ARM ones).
 313  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mthumb" )
 314  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthumb" )
 315 else()
 316  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -marm" )
 317  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -marm" )
 318 endif()
 319
 320 if( BUILD_WITH_ANDROID_NDK )
 321  set( CMAKE_CXX_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_CXX_FLAGS}" )
 322  set( CMAKE_C_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_C_FLAGS}" )
 323
 324  # workaround for ugly cmake bug - compiler identification replaces all spaces (and somethimes " !!!) in compiler flags with ; symbol
 325  # as result identification fails if ANDROID_NDK_SYSROOT contain spaces
 326  include(CMakeForceCompiler)
 327  CMAKE_FORCE_C_COMPILER("${CMAKE_C_COMPILER}" GNU)
 328  CMAKE_FORCE_CXX_COMPILER("${CMAKE_CXX_COMPILER}" GNU)
 329 endif()
 330
 331 if( ARMEABI_V7A )
 332  #these are required flags for android armv7-a
 333  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
 334  set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
 335  if( NEON )
 336   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon" )
 337   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon" )
 338  elseif( VFPV3 )
 339   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfpv3" )
 340   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfpv3" )
 341  endif()
 342 endif()
 343
 344 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags" )
 345 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags" )
 346
 347 #-Wl,-L${LIBCPP_LINK_DIR},-lstdc++,-lsupc++
 348 #-L${LIBCPP_LINK_DIR} -lstdc++ -lsupc++
 349 #Also, this is *required* to use the following linker flags that routes around
 350 #a CPU bug in some Cortex-A8 implementations:
 351 set( LINKER_FLAGS "-Wl,--fix-cortex-a8 -L\"${STL_LIBRARIES_PATH}\" -L\"${CMAKE_INSTALL_PREFIX}/libs/${ARMEABI_NDK_NAME}\" -lstdc++ -lsupc++ " )
 352
 353 set( NO_UNDEFINED ON CACHE BOOL "Don't all undefined symbols" )
 354 if( NO_UNDEFINED )
 355  set( LINKER_FLAGS "-Wl,--no-undefined ${LINKER_FLAGS}" )
 356 endif()
 357
 358 set( CMAKE_SHARED_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
 359 set( CMAKE_MODULE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
 360 set( CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
 361
 362 #set these global flags for cmake client scripts to change behavior
 363 set( ANDROID True )
 364 set( BUILD_ANDROID True )
 365
 366 #macro to find packages on the host OS
 367 macro(find_host_package)
 368  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
 369  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
 370  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
 371  if( CMAKE_HOST_WIN32 )
 372   SET( WIN32 1 )
 373   SET( UNIX )
 374  elseif( CMAKE_HOST_APPLE )
 375   SET( APPLE 1 )
 376   SET( UNIX )
 377  endif()
 378  find_package( ${ARGN} )
 379  SET( WIN32 )
 380  SET( APPLE )
 381  SET( UNIX 1)
 382  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 383  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 384  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 385 endmacro()
 386 #macro to find programs on the host OS
 387 macro(find_host_program)
 388  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
 389  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
 390  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
 391  if( CMAKE_HOST_WIN32 )
 392   SET( WIN32 1 )
 393   SET( UNIX )
 394  elseif( CMAKE_HOST_APPLE )
 395   SET( APPLE 1 )
 396   SET( UNIX )
 397  endif()
 398  find_program( ${ARGN} )
 399  SET( WIN32 )
 400  SET( APPLE )
 401  SET( UNIX 1)
 402  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 403  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 404  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 405 endmacro()
 406
 407 MARK_AS_ADVANCED(FORCE_ARM NO_UNDEFINED)