[RFC] Port to Android

This adds an Android target for the stdlib. It is also the first
example of cross-compiling outside of Darwin.

Mailing list discussions:

1. https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151207/000171.html
2. https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151214/000492.html

The Android variant of Swift may be built and tested using the
following `build-script` invocation:

```
$ utils/build-script \
  -R \                                           # Build in ReleaseAssert mode.
  -T \                                           # Run all tests.
  --android \                                    # Build for Android.
  --android-deploy-device-path /data/local/tmp \ # Temporary directory on the device where Android tests are run.
  --android-ndk ~/android-ndk-r10e \             # Path to an Android NDK.
  --android-ndk-version 21 \
  --android-icu-uc ~/libicu-android/armeabi-v7a/libicuuc.so \
  --android-icu-uc-include ~/libicu-android/armeabi-v7a/icu/source/common \
  --android-icu-i18n ~/libicu-android/armeabi-v7a/libicui18n.so \
  --android-icu-i18n-include ~/libicu-android/armeabi-v7a/icu/source/i18n/
```

Android builds have the following dependencies, as can be seen in
the build script invocation:

1. An Android NDK of version 21 or greater, available to download
   here: http://developer.android.com/ndk/downloads/index.html.
2. A libicu compatible with android-armv7.

Author: zhuowei

CMakeLists.txt

@@ -125,6 +125,21 @@ set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "" CACHE STRING
 option(SWIFT_ENABLE_LTO
   "If set to true, build the swift compiler with link time optimization enabled" FALSE)
 
+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_TOOLCHAIN_VERSION "" CACHE STRING
+  "A version of the toolchain to use when building for Android. Use 4.8 for 32-bit builds, 4.9 for 64-bit builds")
+set(SWIFT_ANDROID_SDK_PATH "" CACHE STRING
+  "Path to the directory that contains the Android SDK tools that will be linked to the swiftc frontend")
+set(SWIFT_ANDROID_ICU_UC "" CACHE STRING
+  "Path to a directory containing libicuuc.so")
+set(SWIFT_ANDROID_ICU_UC_INCLUDE "" CACHE STRING
+  "Path to a directory containing headers for libicuuc")
+set(SWIFT_ANDROID_ICU_I18N "" CACHE STRING
+  "Path to a directory containing libicui18n.so")
+set(SWIFT_ANDROID_ICU_I18N_INCLUDE "" CACHE STRING
+  "Path to a directory containing headers libicui18n")
+
 #
 # User-configurable Darwin-specific options.
 #
@@ -408,9 +423,27 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
 
   # FIXME: This will not work while trying to cross-compile.
   if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
-    configure_sdk_unix(LINUX "Linux" "linux" "linux" "x86_64" "x86_64-unknown-linux-gnu")
     set(SWIFT_HOST_VARIANT_ARCH "x86_64")
     set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64")
+
+    set(swift_can_crosscompile_stdlib TRUE)
+
+    is_sdk_requested(LINUX swift_build_linux)
+    if(swift_build_linux)
+      configure_sdk_unix(LINUX "Linux" "linux" "linux" "x86_64" "x86_64-unknown-linux-gnu")
+      set(SWIFT_PRIMARY_VARIANT_SDK_default "LINUX")
+      set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64")
+    endif()
+
+    is_sdk_requested(ANDROID swift_build_android)
+    if(swift_build_android AND ${swift_can_crosscompile_stdlib})
+      configure_sdk_unix(ANDROID "Android" "android" "android" "armv7" "armv7-none-linux-androideabi")
+      set(SWIFT_SDK_ANDROID_PATH "${SWIFT_ANDROID_SDK_PATH}")
+
+      set(SWIFT_PRIMARY_VARIANT_SDK_default "ANDROID")
+      set(SWIFT_PRIMARY_VARIANT_ARCH_default "armv7")
+    endif()
+
   # FIXME: This only matches ARMv6l (by far the most common variant).
   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv6l")
     configure_sdk_unix(LINUX "Linux" "linux" "linux" "armv6" "armv6-unknown-linux-gnueabihf")

cmake/modules/AddSwift.cmake

@@ -57,6 +57,14 @@ function(_add_variant_c_compile_link_flags
   list(APPEND result
     "-isysroot" "${SWIFT_SDK_${sdk}_PATH}")
 
+  if("${sdk}" STREQUAL "ANDROID")
+    list(APPEND result
+      "--sysroot=${SWIFT_ANDROID_SDK_PATH}"
+      # Use the linker included in the Android NDK.
+      "-B" "${SWIFT_ANDROID_NDK_PATH}/toolchains/arm-linux-androideabi-${SWIFT_ANDROID_NDK_TOOLCHAIN_VERSION}/prebuilt/linux-x86_64/arm-linux-androideabi/bin/")
+  endif()
+
+
   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
     list(APPEND result
         "-arch" "${arch}"
@@ -120,6 +128,13 @@ function(_add_variant_c_compile_flags
                        "-fcoverage-mapping")
   endif()
 
+  if("${sdk}" STREQUAL "ANDROID")
+    list(APPEND result
+        "-I${SWIFT_ANDROID_NDK_PATH}/sources/cxx-stl/llvm-libc++/libcxx/include"
+        "-I${SWIFT_ANDROID_NDK_PATH}/sources/cxx-stl/llvm-libc++abi/libcxxabi/include"
+        "-I${SWIFT_ANDROID_NDK_PATH}/sources/android/support/include")
+  endif()
+
   set("${result_var_name}" "${result}" PARENT_SCOPE)
 endfunction()
 
@@ -179,11 +194,20 @@ function(_add_variant_link_flags
       result)
 
   if("${sdk}" STREQUAL "LINUX")
-    list(APPEND result "-lpthread" "-ldl")
+    list(APPEND result "-lpthread" "-ldl"
+      # Include libbsd, which includes dependencies needed by Android stdlib
+      # targets, such as `arc4random_uniform`.
+      "${BSD_LIBRARIES}")
   elseif("${sdk}" STREQUAL "FREEBSD")
     list(APPEND result "-lpthread")
   elseif("${sdk}" STREQUAL "CYGWIN")
     # No extra libraries required.
+  elseif("${sdk}" STREQUAL "ANDROID")
+    list(APPEND result
+        "-ldl"
+        "-L${SWIFT_ANDROID_NDK_PATH}/toolchains/arm-linux-androideabi-${SWIFT_ANDROID_NDK_TOOLCHAIN_VERSION}/prebuilt/linux-x86_64/lib/gcc/arm-linux-androideabi/${SWIFT_ANDROID_NDK_TOOLCHAIN_VERSION}"
+        "${SWIFT_ANDROID_NDK_PATH}/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/libc++_shared.so"
+        "-L${SWIFT_ANDROID_ICU_UC}" "-L${SWIFT_ANDROID_ICU_I18N}")
   else()
     list(APPEND result "-lobjc")
   endif()
@@ -967,7 +991,7 @@ function(_add_swift_library_single target name)
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_NAME_DIR "${install_name_dir}")
-  elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+  elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND NOT "${SWIFTLIB_SINGLE_SDK}" STREQUAL "ANDROID")
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/linux")

cmake/modules/FindICU.cmake

@@ -25,5 +25,12 @@ foreach(MODULE ${ICU_FIND_COMPONENTS})
   endif()
 endforeach()
 
+if(NOT "${SWIFT_ANDROID_ICU_UC_INCLUDE}" STREQUAL "")
+  set(ICU_UC_INCLUDE_DIR "${SWIFT_ANDROID_ICU_UC_INCLUDE}")
+endif()
+if(NOT "${SWIFT_ANDROID_ICU_I18N_INCLUDE}" STREQUAL "")
+  set(ICU_I18N_INCLUDE_DIR "${SWIFT_ANDROID_ICU_I18N_INCLUDE}")
+endif()
+
 find_package_handle_standard_args(ICU DEFAULT_MSG ${ICU_REQUIRED})
 mark_as_advanced(${ICU_REQUIRED})

docs/Testing.rst

@@ -107,6 +107,48 @@ targets mentioned above and modify it as necessary. lit.py also has several
 useful features, like timing tests and providing a timeout. Check these features
 out with ``lit.py -h``.
 
+Running tests hosted on an Android device
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You may run tests targeting android-armv7 by connecting a device to run the
+tests on, then pushing the necessary dependencies to that device.
+
+1. Connect your Android device to your computer via USB. Ensure that remote
+   debugging is enabled for that device by following the official instructions:
+   https://developer.chrome.com/devtools/docs/remote-debugging.
+2. Confirm the device is connected by running ``adb devices``. You should see
+   your device listed.
+3. Push the built products for android-armv7 to your device, using the
+   ``utils/android/adb_push_built_products.py`` script. For example, to push
+   the built products at a build directory
+   ``~/swift/Ninja-ReleaseAssert/swift-linux-x86_64``, with an Android NDK
+   placed at ``~/android-ndk-r10e``, run the following:
+
+       $ utils/android/adb_push_built_products.py \
+             ~/swift/build/Ninja-ReleaseAssert/swift-linux-x86_64/lib/swift/android/ \
+             --ndk ~/android-ndk-r10e
+4. Run the test suite for the ``android-armv7`` target.
+
+You may run the tests using the build script as well. Specifying a
+``--android-deploy-device-path`` pushes the built Android products to your
+device as part of the build:
+
+    $ utils/build-script \
+      -R \                                           # Build in ReleaseAssert mode.
+      -T \                                           # Run all tests.
+      --android \                                    # Build for Android.
+      --android-deploy-device-path /data/local/tmp \ # Temporary directory on the device where Android tests are run.
+      --android-ndk ~/android-ndk-r10e \             # Path to an Android NDK.
+      --android-ndk-version 21 \
+      --android-icu-uc ~/libicu-android/armeabi-v7a/libicuuc.so \
+      --android-icu-uc-include ~/libicu-android/armeabi-v7a/icu/source/common \
+      --android-icu-i18n ~/libicu-android/armeabi-v7a/libicui18n.so \
+      --android-icu-i18n-include ~/libicu-android/armeabi-v7a/icu/source/i18n/
+
+You must run the Linux tests once in order to build the Android test suite.
+After that, you may run the above command with the ``--skip-test-linux`` option
+to only run Android tests.
+
 Writing tests
 -------------
 

lib/Basic/LangOptions.cpp

@@ -30,7 +30,8 @@ static const StringRef SupportedConditionalCompilationOSs[] = {
   "iOS",
   "Linux",
   "FreeBSD",
-  "Windows"
+  "Windows",
+  "Android"
 };
 
 static const StringRef SupportedConditionalCompilationArches[] = {
@@ -105,6 +106,8 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
     addPlatformConditionValue("os", "watchOS");
   else if (triple.isiOS())
     addPlatformConditionValue("os", "iOS");
+  else if (triple.isAndroid())
+    addPlatformConditionValue("os", "Android");
   else if (triple.isOSLinux())
     addPlatformConditionValue("os", "Linux");
   else if (triple.isOSFreeBSD())

lib/Basic/Platform.cpp

@@ -58,6 +58,10 @@ StringRef swift::getPlatformNameForTriple(const llvm::Triple &triple) {
     return "watchos";
   }
 
+  if (triple.isAndroid()) {
+    return "android";
+  }
+
   if (triple.isMacOSX())
     return "macosx";
 

lib/ClangImporter/MappedTypes.def

@@ -127,6 +127,7 @@ MAP_STDLIB_TYPE("u_int64_t", UnsignedInt, 64, "UInt64", false, DoNothing)
 // FIXME: why does this not catch va_list on x86_64?
 MAP_STDLIB_TYPE("va_list", VaList, 0, "CVaListPointer", false, DoNothing)
 MAP_STDLIB_TYPE("__gnuc_va_list", VaList, 0, "CVaListPointer", false, DoNothing)
+MAP_STDLIB_TYPE("__va_list", VaList, 0, "CVaListPointer", false, DoNothing)
 
 // libkern/OSTypes.h types.
 MAP_STDLIB_TYPE("UInt", UnsignedInt, 32, "CUnsignedInt", false, DoNothing)

lib/Driver/ToolChains.cpp

@@ -1211,12 +1211,33 @@ toolchains::GenericUnix::constructInvocation(const LinkJobAction &job,
     Arguments.push_back(context.Args.MakeArgString(LibProfile));
   }
 
-  // FIXME: We probably shouldn't be adding an rpath here unless we know ahead
-  // of time the standard library won't be copied.
-  Arguments.push_back("-Xlinker");
-  Arguments.push_back("-rpath");
-  Arguments.push_back("-Xlinker");
-  Arguments.push_back(context.Args.MakeArgString(RuntimeLibPath));
+  if (getTriple().isAndroid()) {
+    // FIXME: These should be set in CMake.
+    Arguments.push_back("-target");
+    Arguments.push_back("armv7-none-linux-androideabi");
+
+    const char* ndkhome = getenv("ANDROID_NDK_HOME");
+    assert(ndkhome && "ANDROID_NDK_HOME needs to be set to NDK "
+      "install directory for linking");
+
+    auto libgccpath = Twine(ndkhome) + "/toolchains/"
+      "arm-linux-androideabi-4.8/prebuilt/linux-x86_64/"
+      "lib/gcc/arm-linux-androideabi/4.8";
+    Arguments.push_back("-L");
+    Arguments.push_back(context.Args.MakeArgString(libgccpath));
+
+    auto libcxxpath = Twine(ndkhome) + "/sources/"
+      "cxx-stl/llvm-libc++/libs/armeabi-v7a";
+    Arguments.push_back("-L");
+    Arguments.push_back(context.Args.MakeArgString(libcxxpath));
+  } else {
+    // FIXME: We probably shouldn't be adding an rpath here unless we know ahead
+    // of time the standard library won't be copied.
+    Arguments.push_back("-Xlinker");
+    Arguments.push_back("-rpath");
+    Arguments.push_back("-Xlinker");
+    Arguments.push_back(context.Args.MakeArgString(RuntimeLibPath));
+  }
 
   // Always add the stdlib
   Arguments.push_back("-lswiftCore");

stdlib/private/StdlibUnittest/RaceTest.swift

@@ -40,7 +40,7 @@ import SwiftPrivate
 import SwiftPrivatePthreadExtras
 #if os(OSX) || os(iOS)
 import Darwin
-#elseif os(Linux) || os(FreeBSD)
+#elseif os(Linux) || os(FreeBSD) || os(Android)
 import Glibc
 #endif
 

stdlib/private/StdlibUnittest/StdlibCoreExtras.swift

@@ -14,7 +14,7 @@ import SwiftPrivate
 import SwiftPrivateLibcExtras
 #if os(OSX) || os(iOS)
 import Darwin
-#elseif os(Linux) || os(FreeBSD)
+#elseif os(Linux) || os(FreeBSD) || os(Android)
 import Glibc
 #endif
 

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -16,7 +16,7 @@ import SwiftPrivateLibcExtras
 
 #if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
 import Darwin
-#elseif os(Linux) || os(FreeBSD)
+#elseif os(Linux) || os(FreeBSD) || os(Android)
 import Glibc
 #endif
 
@@ -1034,6 +1034,7 @@ public enum OSVersion : CustomStringConvertible {
   case watchOSSimulator
   case Linux
   case FreeBSD
+  case Android
 
   public var description: String {
     switch self {
@@ -1055,6 +1056,8 @@ public enum OSVersion : CustomStringConvertible {
       return "Linux"
     case FreeBSD:
       return "FreeBSD"
+    case Android:
+      return "Android"
     }
   }
 }
@@ -1089,6 +1092,8 @@ func _getOSVersion() -> OSVersion {
   return .Linux
 #elseif os(FreeBSD)
   return .FreeBSD
+#elseif os(Android)
+  return .Android
 #else
   let productVersion = _stdlib_getSystemVersionPlistProperty("ProductVersion")!
   let (major, minor, bugFix) = _parseDottedVersionTriple(productVersion)
@@ -1160,6 +1165,7 @@ public enum TestRunPredicate : CustomStringConvertible {
   case watchOSSimulatorAny(/*reason:*/ String)
 
   case LinuxAny(reason: String)
+  case AndroidAny(reason: String)
 
   case FreeBSDAny(reason: String)
 
@@ -1243,6 +1249,9 @@ public enum TestRunPredicate : CustomStringConvertible {
     case FreeBSDAny(reason: let reason):
       return "FreeBSDAny(*, reason: \(reason))"
 
+    case AndroidAny(reason: let reason):
+      return "AndroidAny(*, reason: \(reason))"
+
     case ObjCRuntime(let reason):
       return "Objective-C runtime, reason: \(reason))"
     case NativeRuntime(let reason):
@@ -1492,6 +1501,14 @@ public enum TestRunPredicate : CustomStringConvertible {
         return false
       }
 
+    case AndroidAny:
+      switch _getRunningOSVersion() {
+      case .Android:
+        return true
+      default:
+        return false
+      }
+
     case ObjCRuntime:
 #if _runtime(_ObjC)
       return true