Merge pull request swiftlang#39791 from apple/revert-39045-android-ndk-23

Revert "[android] Update to NDK 23"

Author: compnerd

CMakeLists.txt

@@ -180,8 +180,6 @@ set(CLANG_COMPILER_VERSION "" CACHE STRING
 # build environment.
 if(LLVM_USE_LINKER)
   set(SWIFT_USE_LINKER_default "${LLVM_USE_LINKER}")
-elseif(${SWIFT_HOST_VARIANT_SDK} STREQUAL ANDROID)
-  set(SWIFT_USE_LINKER_default "lld")
 elseif(CMAKE_SYSTEM_NAME STREQUAL Windows AND NOT CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
   set(SWIFT_USE_LINKER_default "lld")
 elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
@@ -308,8 +306,8 @@ set(SWIFT_ANDROID_API_LEVEL "" CACHE STRING
 
 set(SWIFT_ANDROID_NDK_PATH "" CACHE STRING
   "Path to the directory that contains the Android NDK tools that are executable on the build machine")
-set(SWIFT_ANDROID_NDK_CLANG_VERSION "12.0.5" CACHE STRING
-  "The Clang version to use when building for Android.")
+set(SWIFT_ANDROID_NDK_GCC_VERSION "" CACHE STRING
+  "The GCC version to use when building for Android. Currently only 4.9 is supported.")
 set(SWIFT_ANDROID_DEPLOY_DEVICE_PATH "" CACHE STRING
   "Path on an Android device where build products will be pushed. These are used when running the test suite against the device")
 

cmake/modules/AddSwift.cmake

@@ -145,9 +145,12 @@ function(_add_host_variant_c_compile_link_flags name)
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
-    # Make sure the Android NDK lld is used.
-    swift_android_tools_path(${SWIFT_HOST_VARIANT_ARCH} tools_path)
-    target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-B${tools_path}>)
+    # lld can handle targeting the android build.  However, if lld is not
+    # enabled, then fallback to the linker included in the android NDK.
+    if(NOT SWIFT_USE_LINKER STREQUAL "lld")
+      swift_android_tools_path(${SWIFT_HOST_VARIANT_ARCH} tools_path)
+      target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-B${tools_path}>)
+    endif()
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
@@ -381,6 +384,11 @@ function(_add_host_variant_link_flags target)
       cxx_link_libraries)
     target_link_libraries(${target} PRIVATE
       ${cxx_link_libraries})
+
+    swift_android_libgcc_for_arch_cross_compile(${SWIFT_HOST_VARIANT_ARCH}
+      ${SWIFT_HOST_VARIANT_ARCH}_LIB)
+    target_link_directories(${target} PRIVATE
+      ${${SWIFT_HOST_VARIANT_ARCH}_LIB})
   else()
     # If lto is enabled, we need to add the object path flag so that the LTO code
     # generator leaves the intermediate object file in a place where it will not

cmake/modules/AddSwiftUnittests.cmake

@@ -32,6 +32,9 @@ function(add_swift_unittest test_dirname)
       COMMAND "${SWIFT_SOURCE_DIR}/utils/swift-rpathize.py"
               "$<TARGET_FILE:${test_dirname}>")
   elseif("${SWIFT_HOST_VARIANT}" STREQUAL "android")
+    swift_android_libgcc_for_arch_cross_compile(${SWIFT_HOST_VARIANT_ARCH} android_system_libs)
+    set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_DIRECTORIES
+      "${android_system_libs}")
     set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_LIBRARIES "log")
   elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")

cmake/modules/SwiftAndroidSupport.cmake

@@ -1,7 +1,28 @@
+function(swift_android_prebuilt_host_name prebuilt_var_name)
+  # Get the prebuilt suffix to create the correct toolchain path when using the NDK
+  if(CMAKE_HOST_SYSTEM_NAME STREQUAL Darwin)
+    set(${prebuilt_var_name} darwin-x86_64 PARENT_SCOPE)
+  elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Linux)
+    set(${prebuilt_var_name} linux-x86_64 PARENT_SCOPE)
+  elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+    set(${prebuilt_var_name} Windows-x86_64 PARENT_SCOPE)
+  else()
+    message(SEND_ERROR "cannot cross-compile to android from ${CMAKE_HOST_SYSTEM_NAME}")
+  endif()
+endfunction()
+
+function(swift_android_libgcc_for_arch_cross_compile arch var)
+  set(paths)
+  if(NOT "${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")
+    list(APPEND paths "${SWIFT_SDK_ANDROID_ARCH_${arch}_PATH}/../lib/gcc/${SWIFT_SDK_ANDROID_ARCH_${arch}_NDK_TRIPLE}/${SWIFT_ANDROID_NDK_GCC_VERSION}.x")
+  endif()
+  set(${var} ${paths} PARENT_SCOPE)
+endfunction()
+
 function(swift_android_sysroot sysroot_var_name)
   if(NOT "${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")
-    string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} platform)
-    set(${sysroot_var_name} "${SWIFT_ANDROID_NDK_PATH}/toolchains/llvm/prebuilt/${platform}-x86_64/sysroot" PARENT_SCOPE)
+    swift_android_prebuilt_host_name(prebuilt_build)
+    set(${sysroot_var_name} "${SWIFT_ANDROID_NDK_PATH}/toolchains/llvm/prebuilt/${prebuilt_build}/sysroot" PARENT_SCOPE)
   elseif(NOT "${SWIFT_ANDROID_NATIVE_SYSROOT}" STREQUAL "")
     set(${sysroot_var_name} "${SWIFT_ANDROID_NATIVE_SYSROOT}" PARENT_SCOPE)
   else()
@@ -11,8 +32,19 @@ endfunction()
 
 function(swift_android_tools_path arch path_var_name)
   if(NOT "${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")
-    string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} platform)
-    set(${path_var_name} "${SWIFT_ANDROID_NDK_PATH}/toolchains/llvm/prebuilt/${platform}-x86_64/bin" PARENT_SCOPE)
+    swift_android_prebuilt_host_name(prebuilt_build)
+    if("${arch}" STREQUAL "i686")
+      set(ndk_prebuilt_path
+        "${SWIFT_ANDROID_NDK_PATH}/toolchains/x86-${SWIFT_ANDROID_NDK_GCC_VERSION}/prebuilt/${prebuilt_build}")
+    elseif("${arch}" STREQUAL "x86_64")
+      set(ndk_prebuilt_path
+        "${SWIFT_ANDROID_NDK_PATH}/toolchains/x86_64-${SWIFT_ANDROID_NDK_GCC_VERSION}/prebuilt/${prebuilt_build}")
+    else()
+      set(ndk_prebuilt_path
+        "${SWIFT_ANDROID_NDK_PATH}/toolchains/${SWIFT_SDK_ANDROID_ARCH_${arch}_NDK_TRIPLE}-${SWIFT_ANDROID_NDK_GCC_VERSION}/prebuilt/${prebuilt_build}")
+    endif()
+
+    set(${path_var_name} "${ndk_prebuilt_path}/${SWIFT_SDK_ANDROID_ARCH_${arch}_NDK_TRIPLE}/bin" PARENT_SCOPE)
   elseif(NOT "${SWIFT_ANDROID_NATIVE_SYSROOT}" STREQUAL "")
     set(${path_var_name} "${SWIFT_ANDROID_NATIVE_SYSROOT}/usr/bin" PARENT_SCOPE)
   else()

docs/Android.md

@@ -33,8 +33,8 @@ To follow along with this guide, you'll need:
    Ubuntu 18.04 or Ubuntu 16.04. Before attempting to build for Android,
    please make sure you are able to build for Linux by following the
    instructions in the Swift project README.
-2. The latest version of the Android NDK (r23 at the time of this writing),
-   available to download here:
+2. The latest version of the Android NDK (r21e at the time of this writing,
+   only r19 or later are supported), available to download here:
    https://developer.android.com/ndk/downloads/index.html.
 3. An Android device with remote debugging enabled or the emulator. We require
    remote debugging in order to deploy built stdlib products to the device. You
@@ -73,7 +73,7 @@ Android NDK, as well as the directories that contain the `libicuucswift.so` and
 
 ```
 $ ARM_DIR=path/to/libiconv-libicu-android/armeabi-v7a
-$ NDK_PATH=path/to/android-ndk-r23
+$ NDK_PATH=path/to/android-ndk-r21e
 $ utils/build-script \
     -R \                                       # Build in ReleaseAssert mode.
     --android \                                # Build for Android.
@@ -99,7 +99,7 @@ Then use the built Swift compiler from the previous step to compile a Swift
 source file, targeting Android:
 
 ```
-$ NDK_PATH="path/to/android-ndk-r23"
+$ NDK_PATH="path/to/android-ndk-r21e"
 $ build/Ninja-ReleaseAssert/swift-linux-x86_64/bin/swiftc \          # The Swift compiler built in the previous step
                                                                      # The location of the tools used to build Android binaries
     -tools-directory ${NDK_PATH}/toolchains/llvm/prebuilt/linux-x86_64/bin/ \
@@ -153,7 +153,7 @@ adb push /path/to/libicu-android/armeabi-v7a/libicuucswift.so /data/local/tmp
 In addition, you'll also need to copy the Android NDK's libc++:
 
 ```
-$ adb push /path/to/android-ndk-r23/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/libc++_shared.so /data/local/tmp
+$ adb push /path/to/android-ndk-r21e/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/libc++_shared.so /data/local/tmp
 ```
 
 Finally, you'll need to copy the `hello` executable you built in the
@@ -196,7 +196,7 @@ $ utils/build-script \
   -R \                               # Build in ReleaseAssert mode.
   -T \                               # Run all tests, including on the Android device (add --host-test to only run Android tests on the linux host).
   --android \                        # Build for Android.
-  --android-ndk ~/android-ndk-r23 \  # Path to an Android NDK.
+  --android-ndk ~/android-ndk-r21e \ # Path to an Android NDK.
   --android-arch armv7 \             # Optionally specify Android architecture, alternately aarch64
   --android-ndk-version 21 \
   --android-icu-uc ~/libicu-android/armeabi-v7a/libicuuc.so \

lib/Driver/UnixToolChains.cpp

@@ -85,9 +85,6 @@ ToolChain::InvocationInfo toolchains::GenericUnix::constructInvocation(
 }
 
 std::string toolchains::GenericUnix::getDefaultLinker() const {
-  if (getTriple().isAndroid())
-    return "lld";
-
   switch (getTriple().getArch()) {
   case llvm::Triple::arm:
   case llvm::Triple::aarch64:

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -94,9 +94,12 @@ function(_add_target_variant_c_compile_link_flags)
   endif()
 
   if("${CFLAGS_SDK}" STREQUAL "ANDROID")
-    # Make sure the Android NDK lld is used.
-    swift_android_tools_path(${CFLAGS_ARCH} tools_path)
-    list(APPEND result "-B" "${tools_path}")
+    # lld can handle targeting the android build.  However, if lld is not
+    # enabled, then fallback to the linker included in the android NDK.
+    if(NOT SWIFT_USE_LINKER STREQUAL "lld")
+      swift_android_tools_path(${CFLAGS_ARCH} tools_path)
+      list(APPEND result "-B" "${tools_path}")
+    endif()
   endif()
 
   if("${CFLAGS_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS)
@@ -402,8 +405,8 @@ function(_add_target_variant_link_flags)
     MACCATALYST_BUILD_FLAVOR  "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
   if("${LFLAGS_SDK}" STREQUAL "LINUX")
     list(APPEND link_libraries "pthread" "dl")
-    if("${LFLAGS_ARCH}" MATCHES "armv6|armv7|i686")
-      list(APPEND link_libraries "atomic")
+    if("${SWIFT_HOST_VARIANT_ARCH}" MATCHES "armv6|armv7|i686")
+      list(APPEND link_libraries PRIVATE "atomic")
     endif()
   elseif("${LFLAGS_SDK}" STREQUAL "FREEBSD")
     list(APPEND link_libraries "pthread")
@@ -430,14 +433,8 @@ function(_add_target_variant_link_flags)
     list(APPEND result "-Wl,-Bsymbolic")
   elseif("${LFLAGS_SDK}" STREQUAL "ANDROID")
     list(APPEND link_libraries "dl" "log")
-    if("${LFLAGS_ARCH}" STREQUAL "armv7")
-      list(APPEND link_libraries "atomic")
-    endif()
     # We need to add the math library, which is linked implicitly by libc++
     list(APPEND result "-lm")
-    if(NOT "${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")
-      list(APPEND result "-resource-dir=${SWIFT_SDK_ANDROID_ARCH_${LFLAGS_ARCH}_PATH}/../lib64/clang/${SWIFT_ANDROID_NDK_CLANG_VERSION}")
-    endif()
 
     # link against the custom C++ library
     swift_android_cxx_libraries_for_arch(${LFLAGS_ARCH} cxx_link_libraries)
@@ -447,6 +444,11 @@ function(_add_target_variant_link_flags)
     list(APPEND link_libraries
       ${SWIFT_ANDROID_${LFLAGS_ARCH}_ICU_I18N}
       ${SWIFT_ANDROID_${LFLAGS_ARCH}_ICU_UC})
+
+    swift_android_libgcc_for_arch_cross_compile(${LFLAGS_ARCH} ${LFLAGS_ARCH}_LIB)
+    foreach(path IN LISTS ${LFLAGS_ARCH}_LIB)
+      list(APPEND library_search_directories ${path})
+    endforeach()
   else()
     # If lto is enabled, we need to add the object path flag so that the LTO code
     # generator leaves the intermediate object file in a place where it will not
@@ -474,17 +476,10 @@ function(_add_target_variant_link_flags)
   endif()
 
   if(SWIFT_USE_LINKER AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    # The linker is normally chosen based on the host, but the Android NDK only
-    # uses lld now.
-    if("${LFLAGS_SDK}" STREQUAL "ANDROID")
-      set(linker "lld")
-    else()
-      set(linker "${SWIFT_USE_LINKER}")
-    endif()
     if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
-      list(APPEND result "-fuse-ld=${linker}.exe")
+      list(APPEND result "-fuse-ld=${SWIFT_USE_LINKER}.exe")
     else()
-      list(APPEND result "-fuse-ld=${linker}")
+      list(APPEND result "-fuse-ld=${SWIFT_USE_LINKER}")
     endif()
   endif()
 

stdlib/public/runtime/CMakeLists.txt

@@ -229,7 +229,7 @@ foreach(sdk ${SWIFT_SDKS})
       endif()
       set(libpthread -lpthread)
       set(android_libraries)
-      if(${sdk} STREQUAL ANDROID)
+      if(sdk STREQUAL ANDROID)
         set(android_libraries -llog)
         set(libpthread)
       endif()

test/AutoDiff/validation-test/reflection.swift

@@ -1,5 +1,4 @@
 // REQUIRES: no_asan
-// UNSUPPORTED: OS=linux-android, OS=linux-androideabi
 // RUN: %empty-directory(%t)
 import _Differentiation