From 95493f673d668cbaf7c7e660de86ed3fe6b0fdf2 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Wed, 27 Mar 2024 13:49:42 -0700 Subject: [PATCH 01/15] [android] add a module map for Android NDK This commit doesn't install them yet, they will be installed and a whole Android NDK module will be built in a follow-up commit This module map covers the Bionic C standard library and other Posix headers used in the Android NDK --- stdlib/public/Platform/SwiftAndroidNDK.h | 148 +++++ stdlib/public/Platform/SwiftBionic.h | 38 ++ stdlib/public/Platform/android.modulemap | 683 +++++++++++++++++++++++ 3 files changed, 869 insertions(+) create mode 100644 stdlib/public/Platform/SwiftAndroidNDK.h create mode 100644 stdlib/public/Platform/SwiftBionic.h create mode 100644 stdlib/public/Platform/android.modulemap diff --git a/stdlib/public/Platform/SwiftAndroidNDK.h b/stdlib/public/Platform/SwiftAndroidNDK.h new file mode 100644 index 0000000000000..791ac40ec4336 --- /dev/null +++ b/stdlib/public/Platform/SwiftAndroidNDK.h @@ -0,0 +1,148 @@ +//===--- SwiftAndroidNDK.h ------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +#ifndef SWIFT_ANDROID_NDK_MODULE +#define SWIFT_ANDROID_NDK_MODULE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// C headers that are included with the compiler. +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#endif // SWIFT_ANDROID_NDK_MODULE diff --git a/stdlib/public/Platform/SwiftBionic.h b/stdlib/public/Platform/SwiftBionic.h new file mode 100644 index 0000000000000..b3e173030f18b --- /dev/null +++ b/stdlib/public/Platform/SwiftBionic.h @@ -0,0 +1,38 @@ +//===--- SwiftBionic.h ----------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +#ifndef SWIFT_BIONIC_MODULE +#define SWIFT_BIONIC_MODULE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // SWIFT_BIONIC_MODULE diff --git a/stdlib/public/Platform/android.modulemap b/stdlib/public/Platform/android.modulemap new file mode 100644 index 0000000000000..9a0591488cd83 --- /dev/null +++ b/stdlib/public/Platform/android.modulemap @@ -0,0 +1,683 @@ +//===--- android.modulemap ------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// +// The module map for the Android NDK. +// A portion of the modules in this file are prefixed +// with an underscore, to discourage users from importing them from +// Swift directly, as these modules might be overriden by the C++ stdlib. +// Instead, users should import 'Android' or another +// umbrella module that includes these headers. + +// The top level 'Android' module can be included from Swift. +module SwiftAndroid [system] { + header "SwiftAndroidNDK.h" + export * +} + +// The top level 'Bionic' module is the C standard library +// used in the Android NDK. +module Bionic [system] { + header "SwiftBionic.h" + export * +} + +// The individual modules for the Bionic C standard library used +// by the Android NDK. +module _assert [system] { + // 's use of NDEBUG requires textual inclusion. + textual header "assert.h" +} +module _complex [system] { + header "complex.h" + export * +} +module _ctype [system] { + header "ctype.h" + export * +} +module _errno [system] { + header "errno.h" + export * +} +module _fenv [system] { + header "fenv.h" + export * +} +// Use 'no_undeclared_includes' to avoid pulling in the libc++ headers. +// FIXME: this can be dropped once NDK's libc++ 'std' module is split +// into individual submodules. +module _inttypes [system] [no_undeclared_includes] { + header "inttypes.h" + export * + use _stdint + use _sys_cdefs +} +module _limits [system] { + header "limits.h" + export * + explicit module posix_limits { + header "bits/posix_limits.h" + export * + } +} +module _locale [system] { + header "locale.h" + export * +} +module _malloc [system] { + header "malloc.h" + export * +} +module _math [system] { + header "math.h" + export * + link "m" +} +module _setjmp [system] { + header "setjmp.h" + export * +} +module _signal [system] { + header "signal.h" + // The 'signal.h' header unfortunately has a circular include + // with 'sys/ucontext.h' and thus it must be part of this module. + header "sys/ucontext.h" + export * + explicit module bits_signaltypes { + header "bits/signal_types.h" + export * + } +} +module _stdatomic [system] { + header "stdatomic.h" + export * +} +module _stdint [system] { + header "stdint.h" + export * +} +module _stdio [system] { + header "stdio.h" + export * + explicit module stdio_ext { + header "stdio_ext.h" + export * + } +} +module _stdlib [system] { + header "stdlib.h" + export * +} +module _string [system] { + header "string.h" + export * +} +module _threads [system] { + header "threads.h" + export * + explicit module threads_inlines { + header "bits/threads_inlines.h" + export * + } +} +module _time [system] { + header "time.h" + export * + explicit module sys_time { + header "sys/time.h" + export * + } + explicit module sys_times { + header "sys/times.h" + export * + } +} +module _uchar [system] { + header "uchar.h" + export * +} +module _wchar [system] { + header "wchar.h" + export * + explicit module mbstate_t { + header "bits/mbstate_t.h" + export * + } +} + +// POSIX and another android NDK headers. +module alloca [system] { + header "alloca.h" + export * +} + +module ar [system] { + header "ar.h" + export * +} + +module cpio [system] { + header "cpio.h" + export * +} + +module posix_filesystem [system] { + // This module groups all file, paths and filesystem + // operations into one module. + explicit module dirent { + header "dirent.h" + export * + } + explicit module fcntl { + header "fcntl.h" + // Note: Do not re-export imported modules + // to prevent exporting constants from linux/stat.h . + } + explicit module fnmatch { + header "fnmatch.h" + export * + } + explicit module fts { + header "fts.h" + export * + } + explicit module ftw { + header "ftw.h" + export * + } + explicit module glob { + header "glob.h" + export * + } + explicit module mntent { + header "mntent.h" + export * + } + explicit module libgen { + header "libgen.h" + export * + } + explicit module nl_types { + header "nl_types.h" + export * + } + explicit module paths { + header "paths.h" + export * + } + explicit module poll { + header "poll.h" + export * + } + explicit module pwd { + header "pwd.h" + export * + } + explicit module utime { + header "utime.h" + export * + } + explicit module bits_ioctl { + header "bits/ioctl.h" + export * + } + explicit module linux_stat { + private header "linux/stat.h" + export * + } + explicit module sys_epoll { + header "sys/epoll.h" + export * + } + explicit module sys_eventfd { + header "sys/eventfd.h" + export * + } + explicit module sys_fcntl { + header "sys/fcntl.h" + export * + } + explicit module sys_file { + header "sys/file.h" + export * + } + explicit module sys_inotify { + header "sys/inotify.h" + export * + } + explicit module sys_ioctl { + header "sys/ioctl.h" + export * + } + explicit module sys_mount { + header "sys/mount.h" + export * + } + explicit module sys_sendfile { + header "sys/sendfile.h" + export * + } + explicit module sys_stat { + header "sys/stat.h" + // Note: Do not re-export imported modules + // to prevent exporting constants from linux/stat.h . + } + explicit module sys_statvfs { + header "sys/statvfs.h" + export * + } + explicit module sys_vfs { + header "sys/vfs.h" + export * + } + explicit module sys_uio { + header "sys/uio.h" + export * + } +} + +module dl [system] { + // This module groups all dl* based operations + // into one module. + explicit module dlfcn { + header "dlfcn.h" + export * + } + explicit module link_ { + header "link.h" + export * + } +} + +module error [system] { + header "error.h" + export * + explicit module err { + header "err.h" + export * + } +} + +module execinfo [system] { + header "execinfo.h" + export * +} + +module features [system] { + header "features.h" + export * +} + +module getopt [system] { + header "getopt.h" + export * +} + +module grp [system] { + header "grp.h" + export * +} + +module iconv [system] { + header "iconv.h" + export * +} + +module inet [system] { + // This module groups headers related to inet + // and networking. + explicit module ifaddrs { + header "ifaddrs.h" + export * + } + explicit module netdb { + header "netdb.h" + export * + } + explicit module arpa_inet { + header "arpa/inet.h" + export * + } + explicit module net_if { + header "net/if.h" + export * + } + explicit module netinet_in { + header "netinet/in.h" + export * + } + explicit module netinet_in6 { + header "netinet/in6.h" + export * + } + explicit module netinet_tcp { + header "netinet/tcp.h" + export * + } + explicit module bits_ip_mreq_source { + header "bits/ip_mreq_source.h" + export * + } + explicit module bits_ip_msfilter { + header "bits/ip_msfilter.h" + export * + } + explicit module bits_in_addr { + header "bits/in_addr.h" + export * + } + explicit module linux_if { + header "linux/if.h" + export * + } + explicit module sys_socket { + header "sys/socket.h" + export * + } +} + +module jni [system] { + header "jni.h" + export * +} + +module langinfo [system] { + header "langinfo.h" + export * +} + +module pthread [system] { + header "pthread.h" + export * +} + +module pty [system] { + header "pty.h" + export * +} + +module regex [system] { + header "regex.h" + export * +} + +module resolv [system] { + header "resolv.h" + export * +} + +module sched [system] { + header "sched.h" + export * +} + +module search [system] { + header "search.h" + export * +} + +module semaphore [system] { + header "semaphore.h" + export * +} + +module spawn [system] { + header "spawn.h" + export * +} + +module strings [system] { + header "strings.h" + export * +} + +module sys [system] { + explicit module syscall { + header "syscall.h" + export * + } + explicit module sysexits { + header "sysexits.h" + export * + } + explicit module syslog { + header "syslog.h" + export * + } +} + +module tar [system] { + header "tar.h" + export * +} + +module termio [system] { + explicit module termio { + header "termio.h" + export * + } + explicit module termios { + header "termios.h" + export * + } +} + +module uconfig_local [system] { + header "uconfig_local.h" + export * +} + +module ucontext [system] { + header "ucontext.h" + export * +} + +module unistd [system] { + header "unistd.h" + export * + explicit module sys_unistd { + header "sys/unistd.h" + export * + } +} + +module utmp [system] { + explicit module utmp { + header "utmp.h" + export * + } + explicit module utmpx { + header "utmpx.h" + export * + } +} + +module wait [system] { + header "wait.h" + export * + explicit module sys_wait { + header "sys/wait.h" + export * + } +} + +module xlocale [system] { + header "xlocale.h" + export * +} + +// Additional modules in the 'android' subdirectory. +module android_defs [system] { + explicit module ndk_version { + header "android/ndk-version.h" + export * + } + explicit module versioning { + header "android/versioning.h" + export * + } +} + +module android_apis [system] { + explicit module asset_manager_jni { + header "android/asset_manager_jni.h" + export * + } + explicit module asset_manager { + header "android/asset_manager.h" + export * + } + explicit module log { + header "android/log.h" + export * + } + explicit module trace { + header "android/trace.h" + export * + } +} + +// Additional modules in the 'bits' subdirectory. +module _bits_sa_family_t [system] { + // Note: this module is not part of 'inet' + // to prevent a circular modular dependency. + header "bits/sa_family_t.h" + export * +} +module _bits_stdatomic [system] { + // Note: this module is not part of 'stdatomic' + // as it depends on libc++ and forcing it to + // be in the same module breaks that modularization + // chain. + header "bits/stdatomic.h" + export * +} + +// Additional modules in the 'linux' subdirectory. +module _linux_time [system] { + // Note: this module is not part of '_time' + // to prevent a circular modular dependency + // between linux_time and sys modules. + header "linux/time.h" + header "linux/time_types.h" + export * + explicit module bits_timespec { + header "bits/timespec.h" + export * + } +} + +// Additional modules in the 'sys' subdirectory. +module _sys_cdefs [system] { + header "sys/cdefs.h" + // Circular included header, so combine them + // into the same module. + header "android/api-level.h" + export * +} +module _sys_core [system] { + explicit module endian { + header "sys/endian.h" + export * + } + explicit module errno { + header "sys/errno.h" + export * + } + explicit module ifunc { + header "sys/ifunc.h" + export * + } + explicit module ipc { + header "sys/ipc.h" + export * + } + explicit module mman { + header "sys/mman.h" + export * + } + explicit module mman_common { + header "asm-generic/mman-common.h" + export * + } + explicit module msg { + header "sys/msg.h" + export * + } + explicit module random { + header "sys/random.h" + export * + } + explicit module resource { + header "sys/resource.h" + export * + } + explicit module sem { + header "sys/sem.h" + export * + } + explicit module shm { + header "sys/shm.h" + export * + } + explicit module un { + header "sys/un.h" + export * + } + explicit module utsname { + header "sys/utsname.h" + export * + } +} +module _sys_select [system] { + // Note: this module is not part of + // 'sys_core' to prevent circular dependency error. + header "sys/select.h" + export * +} +// Use 'no_undeclared_includes' to avoid pulling in the libc++ module. +// This module depends on 'stdint.h', which is defined in libc++. +// We can't import libc++ as that would cause circular dependency +// between libc++ and this module. Using 'no_undeclared_includes' +// ensures that we include 'stdint.h' from usr/include instead of libc++. +module _sys_types [system] [no_undeclared_includes] { + header "sys/types.h" + // The 'sys/types.h' header has a circular include + // with 'bits/pthread_types.h' and thus it must be in the same module. + header "bits/pthread_types.h" + export * + use _stdint + use _sys_cdefs + use _Builtin_stddef +} +// Use 'no_undeclared_includes' to avoid pulling in the libc++ module. +// This module depends on 'stdint.h', which is defined in libc++. +// We can't import libc++ as that would cause circular dependency +// between libc++ and this module. Using 'no_undeclared_includes' +// ensures that we include 'stdint.h' from usr/include instead of libc++. +module _sys_user [system] [no_undeclared_includes] { + header "sys/user.h" + export * + use _stdint + use _sys_cdefs + use _Builtin_stddef +} + +// Module for zlib headers. +module zlib [system] { + header "zlib.h" + explicit module zconf { + header "zconf.h" + export * + } + export * + link "z" +} From 57b89d5303271ea0f07cdf5e42374050d5a91ca9 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Wed, 27 Mar 2024 13:53:11 -0700 Subject: [PATCH 02/15] [android] add an android NDK Swift overlay module, and use it instead of Glibc --- lib/ClangImporter/ClangIncludePaths.cpp | 33 ++++--- stdlib/cmake/modules/AddSwiftStdlib.cmake | 15 ++- stdlib/private/RuntimeUnittest/CMakeLists.txt | 1 + .../StdlibCollectionUnittest/CMakeLists.txt | 1 + .../StdlibUnicodeUnittest/CMakeLists.txt | 1 + stdlib/private/StdlibUnittest/CMakeLists.txt | 1 + stdlib/private/StdlibUnittest/RaceTest.swift | 2 + .../StdlibUnittest/StdlibCoreExtras.swift | 2 + .../StdlibUnittest/StdlibUnittest.swift | 2 + stdlib/private/SwiftPrivate/CMakeLists.txt | 1 + stdlib/private/SwiftPrivate/IO.swift | 2 + .../SwiftPrivateLibcExtras/CMakeLists.txt | 1 + .../SwiftPrivateLibcExtras/Subprocess.swift | 2 + .../SwiftPrivateLibcExtras.swift | 2 + .../SwiftPrivateThreadExtras/CMakeLists.txt | 1 + .../SwiftPrivateThreadExtras.swift | 2 + .../ThreadBarriers.swift | 2 + .../SwiftReflectionTest/CMakeLists.txt | 1 + .../SwiftReflectionTest.swift | 2 + stdlib/public/Concurrency/CMakeLists.txt | 1 + stdlib/public/Differentiation/CMakeLists.txt | 1 + .../TgmathDerivatives.swift.gyb | 4 +- stdlib/public/Distributed/CMakeLists.txt | 1 + .../LocalTestingDistributedActorSystem.swift | 2 + stdlib/public/Platform/Android.swift | 88 +++++++++++++++++ stdlib/public/Platform/CMakeLists.txt | 95 ++++++++++++++++++- stdlib/public/Platform/Platform.swift | 2 +- stdlib/public/RegexBuilder/CMakeLists.txt | 1 + stdlib/public/StringProcessing/CMakeLists.txt | 1 + 29 files changed, 250 insertions(+), 20 deletions(-) create mode 100644 stdlib/public/Platform/Android.swift diff --git a/lib/ClangImporter/ClangIncludePaths.cpp b/lib/ClangImporter/ClangIncludePaths.cpp index f5183091bde37..f76fd229c549c 100644 --- a/lib/ClangImporter/ClangIncludePaths.cpp +++ b/lib/ClangImporter/ClangIncludePaths.cpp @@ -180,7 +180,7 @@ createClangArgs(const ASTContext &ctx, clang::driver::Driver &clangDriver) { static SmallVector, 2> getLibcFileMapping(ASTContext &ctx, StringRef modulemapFileName, - std::optional maybeHeaderFileName, + std::optional> maybeHeaderFileNames, const llvm::IntrusiveRefCntPtr &vfs) { const llvm::Triple &triple = ctx.LangOpts.Target; @@ -220,18 +220,20 @@ getLibcFileMapping(ASTContext &ctx, StringRef modulemapFileName, SmallVector, 2> vfsMappings{ {std::string(injectedModuleMapPath), std::string(actualModuleMapPath)}}; - if (maybeHeaderFileName) { - // TODO: remove the SwiftGlibc.h header and reference all Glibc headers - // directly from the modulemap. - Path actualHeaderPath = actualModuleMapPath; - llvm::sys::path::remove_filename(actualHeaderPath); - llvm::sys::path::append(actualHeaderPath, maybeHeaderFileName.value()); + if (maybeHeaderFileNames) { + for (const auto &filename : *maybeHeaderFileNames) { + // TODO: remove the SwiftGlibc.h header and reference all Glibc headers + // directly from the modulemap. + Path actualHeaderPath = actualModuleMapPath; + llvm::sys::path::remove_filename(actualHeaderPath); + llvm::sys::path::append(actualHeaderPath, filename); - Path injectedHeaderPath(libcDir); - llvm::sys::path::append(injectedHeaderPath, maybeHeaderFileName.value()); + Path injectedHeaderPath(libcDir); + llvm::sys::path::append(injectedHeaderPath, filename); - vfsMappings.push_back( - {std::string(injectedHeaderPath), std::string(actualHeaderPath)}); + vfsMappings.push_back( + {std::string(injectedHeaderPath), std::string(actualHeaderPath)}); + } } return vfsMappings; @@ -552,9 +554,14 @@ ClangInvocationFileMapping swift::getClangInvocationFileMapping( } else if (triple.isMusl()) { libcFileMapping = getLibcFileMapping(ctx, "musl.modulemap", StringRef("SwiftMusl.h"), vfs); + } else if (triple.isAndroid()) { + // Android uses the android-specific module map that overlays the NDK. + StringRef headerFiles[] = {"SwiftAndroidNDK.h", "SwiftBionic.h"}; + libcFileMapping = + getLibcFileMapping(ctx, "android.modulemap", headerFiles, vfs); } else if (triple.isOSGlibc() || triple.isOSOpenBSD() || - triple.isOSFreeBSD() || triple.isAndroid()) { - // Android/BSD/Linux Mappings + triple.isOSFreeBSD()) { + // BSD/Linux Mappings libcFileMapping = getLibcFileMapping(ctx, "glibc.modulemap", StringRef("SwiftGlibc.h"), vfs); diff --git a/stdlib/cmake/modules/AddSwiftStdlib.cmake b/stdlib/cmake/modules/AddSwiftStdlib.cmake index b7396781ac6cf..6ca68949ee0c2 100644 --- a/stdlib/cmake/modules/AddSwiftStdlib.cmake +++ b/stdlib/cmake/modules/AddSwiftStdlib.cmake @@ -1757,6 +1757,9 @@ endfunction() # SWIFT_MODULE_DEPENDS_WASI # Swift modules this library depends on when built for WASI. # +# SWIFT_MODULE_DEPENDS_ANDROID +# Swift modules this library depends on when built for Android. +# # FRAMEWORK_DEPENDS # System frameworks this library depends on. # @@ -1880,6 +1883,7 @@ function(add_swift_target_library name) SWIFT_COMPILE_FLAGS_XROS SWIFT_COMPILE_FLAGS_LINUX SWIFT_MODULE_DEPENDS + SWIFT_MODULE_DEPENDS_ANDROID SWIFT_MODULE_DEPENDS_CYGWIN SWIFT_MODULE_DEPENDS_FREEBSD SWIFT_MODULE_DEPENDS_FREESTANDING @@ -2091,12 +2095,15 @@ function(add_swift_target_library name) elseif(sdk STREQUAL "OPENBSD") list(APPEND swiftlib_module_depends_flattened ${SWIFTLIB_SWIFT_MODULE_DEPENDS_OPENBSD}) - elseif(sdk STREQUAL "LINUX" OR sdk STREQUAL "ANDROID") + elseif(sdk STREQUAL "LINUX") list(APPEND swiftlib_module_depends_flattened ${SWIFTLIB_SWIFT_MODULE_DEPENDS_LINUX}) elseif(sdk STREQUAL "LINUX_STATIC") list(APPEND swiftlib_module_depends_flattened ${SWIFTLIB_SWIFT_MODULE_DEPENDS_LINUX_STATIC}) + elseif(sdk STREQUAL "ANDROID") + list(APPEND swiftlib_module_depends_flattened + ${SWIFTLIB_SWIFT_MODULE_DEPENDS_ANDROID}) elseif(sdk STREQUAL "CYGWIN") list(APPEND swiftlib_module_depends_flattened ${SWIFTLIB_SWIFT_MODULE_DEPENDS_CYGWIN}) @@ -2920,6 +2927,7 @@ function(add_swift_target_executable name) DEPENDS LINK_LIBRARIES SWIFT_MODULE_DEPENDS + SWIFT_MODULE_DEPENDS_ANDROID SWIFT_MODULE_DEPENDS_CYGWIN SWIFT_MODULE_DEPENDS_FREEBSD SWIFT_MODULE_DEPENDS_FREESTANDING @@ -3030,12 +3038,15 @@ function(add_swift_target_executable name) elseif(sdk STREQUAL "OPENBSD") list(APPEND swiftexe_module_depends_flattened ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_OPENBSD}) - elseif(sdk STREQUAL "LINUX" OR sdk STREQUAL "ANDROID") + elseif(sdk STREQUAL "LINUX") list(APPEND swiftexe_module_depends_flattened ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_LINUX}) elseif(sdk STREQUAL "LINUX_STATIC") list(APPEND swiftexe_module_depends_flattened ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_LINUX_STATIC}) + elseif(sdk STREQUAL "ANDROID") + list(APPEND swiftexe_module_depends_flattened + ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_ANDROID}) elseif(sdk STREQUAL "CYGWIN") list(APPEND swiftexe_module_depends_flattened ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_CYGWIN}) diff --git a/stdlib/private/RuntimeUnittest/CMakeLists.txt b/stdlib/private/RuntimeUnittest/CMakeLists.txt index e23d3a155c869..992f90ad33d2a 100644 --- a/stdlib/private/RuntimeUnittest/CMakeLists.txt +++ b/stdlib/private/RuntimeUnittest/CMakeLists.txt @@ -8,6 +8,7 @@ add_swift_target_library(swiftRuntimeUnittest ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES ExclusivityTests.cpp SWIFT_MODULE_DEPENDS StdlibUnittest + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/private/StdlibCollectionUnittest/CMakeLists.txt b/stdlib/private/StdlibCollectionUnittest/CMakeLists.txt index 12fc845a887ef..e063340a4e638 100644 --- a/stdlib/private/StdlibCollectionUnittest/CMakeLists.txt +++ b/stdlib/private/StdlibCollectionUnittest/CMakeLists.txt @@ -19,6 +19,7 @@ add_swift_target_library(swiftStdlibCollectionUnittest ${SWIFT_STDLIB_LIBRARY_BU WriteBackMutableSlice.swift SWIFT_MODULE_DEPENDS StdlibUnittest + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/private/StdlibUnicodeUnittest/CMakeLists.txt b/stdlib/private/StdlibUnicodeUnittest/CMakeLists.txt index 6914812465a54..44920a8f62fa8 100644 --- a/stdlib/private/StdlibUnicodeUnittest/CMakeLists.txt +++ b/stdlib/private/StdlibUnicodeUnittest/CMakeLists.txt @@ -10,6 +10,7 @@ add_swift_target_library(swiftStdlibUnicodeUnittest ${SWIFT_STDLIB_LIBRARY_BUILD WordBreaking.swift SWIFT_MODULE_DEPENDS StdlibUnittest + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/private/StdlibUnittest/CMakeLists.txt b/stdlib/private/StdlibUnittest/CMakeLists.txt index 711ee520376c0..dfcbb067d8ff7 100644 --- a/stdlib/private/StdlibUnittest/CMakeLists.txt +++ b/stdlib/private/StdlibUnittest/CMakeLists.txt @@ -62,6 +62,7 @@ add_swift_target_library(swiftStdlibUnittest ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} SWIFT_MODULE_DEPENDS_XROS ${swift_stdlib_unittest_darwin_dependencies} SWIFT_MODULE_DEPENDS_MACCATALYST ${swift_stdlib_unittest_darwin_dependencies} SWIFT_MODULE_DEPENDS_FREESTANDING "${SWIFT_FREESTANDING_TEST_DEPENDENCIES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/private/StdlibUnittest/RaceTest.swift b/stdlib/private/StdlibUnittest/RaceTest.swift index d3aab9cd252fd..0a94d4da05ffb 100644 --- a/stdlib/private/StdlibUnittest/RaceTest.swift +++ b/stdlib/private/StdlibUnittest/RaceTest.swift @@ -45,6 +45,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/StdlibUnittest/StdlibCoreExtras.swift b/stdlib/private/StdlibUnittest/StdlibCoreExtras.swift index 9b5ef8be2e81a..3afef278d4cd5 100644 --- a/stdlib/private/StdlibUnittest/StdlibCoreExtras.swift +++ b/stdlib/private/StdlibUnittest/StdlibCoreExtras.swift @@ -18,6 +18,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/StdlibUnittest/StdlibUnittest.swift b/stdlib/private/StdlibUnittest/StdlibUnittest.swift index 11e60e1dbad41..55171a7114414 100644 --- a/stdlib/private/StdlibUnittest/StdlibUnittest.swift +++ b/stdlib/private/StdlibUnittest/StdlibUnittest.swift @@ -24,6 +24,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/SwiftPrivate/CMakeLists.txt b/stdlib/private/SwiftPrivate/CMakeLists.txt index 480781284ebb7..1e0bbfea54e13 100644 --- a/stdlib/private/SwiftPrivate/CMakeLists.txt +++ b/stdlib/private/SwiftPrivate/CMakeLists.txt @@ -27,6 +27,7 @@ add_swift_target_library(swiftSwiftPrivate ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I SWIFT_MODULE_DEPENDS_WATCHOS ${swift_swiftprivate_darwin_depencencies} SWIFT_MODULE_DEPENDS_MACCATALYST ${swift_swiftprivate_darwin_depencencies} SWIFT_MODULE_DEPENDS_FREESTANDING "${SWIFT_FREESTANDING_TEST_DEPENDENCIES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_LINUX_STATIC Musl SWIFT_MODULE_DEPENDS_FREEBSD Glibc diff --git a/stdlib/private/SwiftPrivate/IO.swift b/stdlib/private/SwiftPrivate/IO.swift index 9e0f3c5ddfe75..e8bf2c659fa0d 100644 --- a/stdlib/private/SwiftPrivate/IO.swift +++ b/stdlib/private/SwiftPrivate/IO.swift @@ -23,6 +23,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif canImport(WASILibc) import WASILibc #endif diff --git a/stdlib/private/SwiftPrivateLibcExtras/CMakeLists.txt b/stdlib/private/SwiftPrivateLibcExtras/CMakeLists.txt index db317dcdf6882..927eae491caa5 100644 --- a/stdlib/private/SwiftPrivateLibcExtras/CMakeLists.txt +++ b/stdlib/private/SwiftPrivateLibcExtras/CMakeLists.txt @@ -38,6 +38,7 @@ add_swift_target_library(swiftSwiftPrivateLibcExtras ${SWIFT_STDLIB_LIBRARY_BUIL SWIFT_MODULE_DEPENDS_XROS ${swift_private_libc_extras_darwin_depencencies} SWIFT_MODULE_DEPENDS_MACCATALYST ${swift_private_libc_extras_darwin_depencencies} SWIFT_MODULE_DEPENDS_FREESTANDING "${SWIFT_FREESTANDING_TEST_DEPENDENCIES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_LINUX_STATIC Musl SWIFT_MODULE_DEPENDS_FREEBSD Glibc diff --git a/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift b/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift index 47e8972a276c2..ad15200ac7518 100644 --- a/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift +++ b/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift @@ -17,6 +17,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift b/stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift index 146cc404931e2..27ee869f70609 100644 --- a/stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift +++ b/stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift @@ -17,6 +17,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/SwiftPrivateThreadExtras/CMakeLists.txt b/stdlib/private/SwiftPrivateThreadExtras/CMakeLists.txt index d0a791ad8a47f..4002af837db10 100644 --- a/stdlib/private/SwiftPrivateThreadExtras/CMakeLists.txt +++ b/stdlib/private/SwiftPrivateThreadExtras/CMakeLists.txt @@ -19,6 +19,7 @@ add_swift_target_library(swiftSwiftPrivateThreadExtras ${SWIFT_STDLIB_LIBRARY_BU SWIFT_MODULE_DEPENDS_XROS ${swift_private_thread_extras_darwin_depencencies} SWIFT_MODULE_DEPENDS_MACCATALYST ${swift_private_thread_extras_darwin_depencencies} SWIFT_MODULE_DEPENDS_FREESTANDING "${SWIFT_FREESTANDING_TEST_DEPENDENCIES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_LINUX_STATIC Musl SWIFT_MODULE_DEPENDS_FREEBSD Glibc diff --git a/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift b/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift index 20d5cdf214087..4ddf17a803136 100644 --- a/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift +++ b/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift @@ -21,6 +21,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift b/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift index 97a5439d9ed4d..e7c43bf02567f 100644 --- a/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift +++ b/stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift @@ -16,6 +16,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/stdlib/private/SwiftReflectionTest/CMakeLists.txt b/stdlib/private/SwiftReflectionTest/CMakeLists.txt index f28b657be7d30..8ad688393765e 100644 --- a/stdlib/private/SwiftReflectionTest/CMakeLists.txt +++ b/stdlib/private/SwiftReflectionTest/CMakeLists.txt @@ -14,6 +14,7 @@ if (SWIFT_INCLUDE_TESTS AND SWIFT_BUILD_DYNAMIC_STDLIB) SWIFT_MODULE_DEPENDS_TVOS ${swift_reflection_test_darwin_depencencies} SWIFT_MODULE_DEPENDS_WATCHOS ${swift_reflection_test_darwin_depencencies} SWIFT_MODULE_DEPENDS_XROS ${swift_reflection_test_darwin_depencencies} + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_LINUX_STATIC Musl SWIFT_MODULE_DEPENDS_FREEBSD Glibc diff --git a/stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift b/stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift index 44175a187da1b..041206cd4244e 100644 --- a/stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift +++ b/stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift @@ -131,6 +131,8 @@ import SwiftShims import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #endif let rtldDefault: UnsafeMutableRawPointer? = nil diff --git a/stdlib/public/Concurrency/CMakeLists.txt b/stdlib/public/Concurrency/CMakeLists.txt index ab19162eb7ced..260744e8829bf 100644 --- a/stdlib/public/Concurrency/CMakeLists.txt +++ b/stdlib/public/Concurrency/CMakeLists.txt @@ -156,6 +156,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I ${SWIFT_RUNTIME_CONCURRENCY_C_SOURCES} ${SWIFT_RUNTIME_CONCURRENCY_SWIFT_SOURCES} + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/public/Differentiation/CMakeLists.txt b/stdlib/public/Differentiation/CMakeLists.txt index 64e0ec3ee15e8..16a296bbbe772 100644 --- a/stdlib/public/Differentiation/CMakeLists.txt +++ b/stdlib/public/Differentiation/CMakeLists.txt @@ -42,6 +42,7 @@ add_swift_target_library(swift_Differentiation ${SWIFT_STDLIB_LIBRARY_BUILD_TYPE SWIFT_MODULE_DEPENDS_TVOS ${swiftDifferentiationDarwinDependencies} SWIFT_MODULE_DEPENDS_WATCHOS ${swiftDifferentiationDarwinDependencies} SWIFT_MODULE_DEPENDS_XROS ${swiftDifferentiationDarwinDependencies} + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_LINUX_STATIC Musl SWIFT_MODULE_DEPENDS_FREEBSD Glibc diff --git a/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb b/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb index a517dade14502..ce28c9c5d079f 100644 --- a/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb +++ b/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb @@ -18,12 +18,14 @@ import Swift import Darwin.C.tgmath #elseif canImport(Musl) import Musl -#elseif os(Linux) || os(FreeBSD) || os(OpenBSD) || os(PS4) || os(Android) || os(Cygwin) || os(Haiku) +#elseif os(Linux) || os(FreeBSD) || os(OpenBSD) || os(PS4) || os(Cygwin) || os(Haiku) import Glibc #elseif os(WASI) import WASILibc #elseif os(Windows) import CRT +#elseif os(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/stdlib/public/Distributed/CMakeLists.txt b/stdlib/public/Distributed/CMakeLists.txt index 3a0dcb21d9832..5dbea7d12f822 100644 --- a/stdlib/public/Distributed/CMakeLists.txt +++ b/stdlib/public/Distributed/CMakeLists.txt @@ -34,6 +34,7 @@ add_swift_target_library(swiftDistributed ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS SWIFT_MODULE_DEPENDS_OSX ${swift_distributed_darwin_depencencies} SWIFT_MODULE_DEPENDS_TVOS ${swift_distributed_darwin_depencencies} SWIFT_MODULE_DEPENDS_WATCHOS ${swift_distributed_darwin_depencencies} + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift b/stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift index 47e31d9019800..33c208bff38ea 100644 --- a/stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift +++ b/stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift @@ -18,6 +18,8 @@ import Darwin import Glibc #elseif canImport(Musl) import Musl +#elseif canImport(Android) +import Android #elseif os(Windows) import WinSDK #endif diff --git a/stdlib/public/Platform/Android.swift b/stdlib/public/Platform/Android.swift new file mode 100644 index 0000000000000..32f71ebdd9b08 --- /dev/null +++ b/stdlib/public/Platform/Android.swift @@ -0,0 +1,88 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +@_exported import SwiftAndroid // Clang module + +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi' or '.pi' to get the value of correct type and avoid casting.") +public let M_PI = Double.pi +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 2' or '.pi / 2' to get the value of correct type and avoid casting.") +public let M_PI_2 = Double.pi / 2 +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 4' or '.pi / 4' to get the value of correct type and avoid casting.") +public let M_PI_4 = Double.pi / 4 + +@available(swift, deprecated: 3.0, message: "Please use 2.squareRoot()'.") +public let M_SQRT2 = 2.squareRoot() + +@available(swift, deprecated: 3.0, message: "Please use 0.5.squareRoot()'.") +public let M_SQRT1_2 = 0.5.squareRoot() + +@available(swift, deprecated: 3.0, message: "Please use 'T.radix' to get the radix of a FloatingPoint type 'T'.") +public let FLT_RADIX = Double.radix + +// Where does the 1 come from? C counts the usually-implicit leading +// significand bit, but Swift does not. Neither is really right or wrong. +@available(swift, deprecated: 3.0, message: "Please use 'Float.significandBitCount + 1'.") +public let FLT_MANT_DIG = Float.significandBitCount + 1 + +// Where does the 1 come from? C models floating-point numbers as having a +// significand in [0.5, 1), but Swift (following IEEE 754) considers the +// significand to be in [1, 2). This rationale applies to FLT_MIN_EXP +// as well. +@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude.exponent + 1'.") +public let FLT_MAX_EXP = Float.greatestFiniteMagnitude.exponent + 1 + +@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude.exponent + 1'.") +public let FLT_MIN_EXP = Float.leastNormalMagnitude.exponent + 1 + +@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.") +public let FLT_MAX = Float.greatestFiniteMagnitude + +@available(swift, deprecated: 3.0, message: "Please use 'Float.ulpOfOne' or '.ulpOfOne'.") +public let FLT_EPSILON = Float.ulpOfOne + +@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude' or '.leastNormalMagnitude'.") +public let FLT_MIN = Float.leastNormalMagnitude + +@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.") +public let FLT_TRUE_MIN = Float.leastNonzeroMagnitude + + +// Where does the 1 come from? C counts the usually-implicit leading +// significand bit, but Swift does not. Neither is really right or wrong. +@available(swift, deprecated: 3.0, message: "Please use 'Double.significandBitCount + 1'.") +public let DBL_MANT_DIG = Double.significandBitCount + 1 + +// Where does the 1 come from? C models floating-point numbers as having a +// significand in [0.5, 1), but Swift (following IEEE 754) considers the +// significand to be in [1, 2). This rationale applies to DBL_MIN_EXP +// as well. +@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude.exponent + 1'.") +public let DBL_MAX_EXP = Double.greatestFiniteMagnitude.exponent + 1 + +@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude.exponent + 1'.") +public let DBL_MIN_EXP = Double.leastNormalMagnitude.exponent + 1 + +@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.") +public let DBL_MAX = Double.greatestFiniteMagnitude + +@available(swift, deprecated: 3.0, message: "Please use 'Double.ulpOfOne' or '.ulpOfOne'.") +public let DBL_EPSILON = Double.ulpOfOne + +@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude' or '.leastNormalMagnitude'.") +public let DBL_MIN = Double.leastNormalMagnitude + +@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.") +public let DBL_TRUE_MIN = Double.leastNonzeroMagnitude + +public let M_LN2 = SwiftAndroid.M_LN2 +public let M_LOG10E = SwiftAndroid.M_LOG10E +public let M_2_SQRTPI = SwiftAndroid.M_2_SQRTPI diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index 31419b092c057..23ddb0a20857c 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -127,9 +127,9 @@ if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB) endforeach() endif() -set(swiftGlibc_target_sdks ANDROID CYGWIN FREEBSD OPENBSD LINUX HAIKU) +set(swiftGlibc_target_sdks CYGWIN FREEBSD OPENBSD LINUX HAIKU) if(SWIFT_FREESTANDING_FLAVOR STREQUAL "linux") - set(swiftGlibc_target_sdks ANDROID CYGWIN FREEBSD OPENBSD LINUX HAIKU FREESTANDING) + set(swiftGlibc_target_sdks CYGWIN FREEBSD OPENBSD LINUX HAIKU FREESTANDING) endif() add_swift_target_library(swiftGlibc ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY ${swift_platform_sources} @@ -273,12 +273,28 @@ add_custom_target(musl_modulemap DEPENDS ${musl_modulemap_target_list}) set_property(TARGET musl_modulemap PROPERTY FOLDER "Miscellaneous") add_dependencies(sdk-overlay musl_modulemap) +add_swift_target_library(swiftAndroid ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY + Android.swift + ${swift_platform_sources} + POSIXError.swift + + GYB_SOURCES + ${swift_platform_gyb_sources} + + SWIFT_COMPILE_FLAGS + ${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS} + ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS} + ${swift_platform_compile_flags} + LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}" + TARGET_SDKS "ANDROID" + INSTALL_IN_COMPONENT sdk-overlay + DEPENDS android_modulemap) + set(glibc_modulemap_target_list) foreach(sdk ${SWIFT_SDKS}) if(NOT "${sdk}" STREQUAL "LINUX" AND NOT "${sdk}" STREQUAL "FREEBSD" AND NOT "${sdk}" STREQUAL "OPENBSD" AND - NOT "${sdk}" STREQUAL "ANDROID" AND NOT "${sdk}" STREQUAL "CYGWIN" AND NOT "${sdk}" STREQUAL "HAIKU") continue() @@ -376,6 +392,79 @@ add_custom_target(glibc_modulemap DEPENDS ${glibc_modulemap_target_list}) set_property(TARGET glibc_modulemap PROPERTY FOLDER "Miscellaneous") add_dependencies(sdk-overlay glibc_modulemap) +set(android_modulemap_target_list) +if("ANDROID" IN_LIST SWIFT_SDKS) + set(android_modulemap_source "android.modulemap") + set(android_ndk_header_source "SwiftAndroidNDK.h") + set(android_bionic_header_source "SwiftBionic.h") + + foreach(arch ${SWIFT_SDK_ANDROID_ARCHITECTURES}) + set(arch_subdir "${SWIFT_SDK_ANDROID_LIB_SUBDIR}/${arch}") + set(module_dir "${SWIFTLIB_DIR}/${arch_subdir}") + set(module_dir_static "${SWIFTSTATICLIB_DIR}/${arch_subdir}") + + add_custom_command_target( + copy_android_modulemap_resource + COMMAND + "${CMAKE_COMMAND}" "-E" "make_directory" ${module_dir} ${module_dir_static} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_modulemap_source}" ${module_dir} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_modulemap_source}" ${module_dir_static} + OUTPUT ${module_dir}/${android_modulemap_source} ${module_dir_static}/${android_modulemap_source} + COMMENT "Copying Android modulemap to resource directories") + add_custom_command_target( + copy_android_ndk_neader_resource + COMMAND + "${CMAKE_COMMAND}" "-E" "make_directory" ${module_dir} ${module_dir_static} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_ndk_header_source}" ${module_dir} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_ndk_header_source}" ${module_dir_static} + OUTPUT ${module_dir}/${android_ndk_header_source} ${module_dir_static}/${android_ndk_header_source} + COMMENT "Copying Android NDK header to resource directories") + add_custom_command_target( + copy_android_bionic_neader_resource + COMMAND + "${CMAKE_COMMAND}" "-E" "make_directory" ${module_dir} ${module_dir_static} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_bionic_header_source}" ${module_dir} + COMMAND + "${CMAKE_COMMAND}" "-E" "copy_if_different" + "${CMAKE_CURRENT_SOURCE_DIR}/${android_bionic_header_source}" ${module_dir_static} + OUTPUT ${module_dir}/${android_bionic_header_source} ${module_dir_static}/${android_bionic_header_source} + COMMENT "Copying Android NDK header to resource directories") + + add_dependencies(sdk-overlay ${copy_android_modulemap_resource} + ${copy_android_ndk_neader_resource} + ${copy_android_bionic_neader_resource}) + list(APPEND android_modulemap_target_list ${copy_android_modulemap_resource} + ${copy_android_ndk_neader_resource} + ${copy_android_bionic_neader_resource}) + + swift_install_in_component(FILES "${android_modulemap_source}" + "${android_ndk_header_source}" + "${android_bionic_header_source}" + DESTINATION "lib/swift/${arch_subdir}" + COMPONENT sdk-overlay) + if(SWIFT_BUILD_STATIC_STDLIB) + swift_install_in_component(FILES "${android_modulemap_source}" + "${android_ndk_header_source}" + "${android_bionic_header_source}" + DESTINATION "lib/swift_static/${arch_subdir}" + COMPONENT sdk-overlay) + endif() + endforeach() +endif() +add_custom_target(android_modulemap DEPENDS ${android_modulemap_target_list}) +set_property(TARGET android_modulemap PROPERTY FOLDER "Miscellaneous") +add_dependencies(sdk-overlay android_modulemap) + set(wasilibc_modulemap_target_list) if("WASI" IN_LIST SWIFT_SDKS) set(wasilibc_modulemap_source "wasi-libc.modulemap") diff --git a/stdlib/public/Platform/Platform.swift b/stdlib/public/Platform/Platform.swift index 0c2d63a0cffdb..b6316445ee573 100644 --- a/stdlib/public/Platform/Platform.swift +++ b/stdlib/public/Platform/Platform.swift @@ -241,7 +241,7 @@ public var S_IFIFO: Int32 { return Int32(0x1000) } public var S_IREAD: Int32 { return Int32(0x0100) } public var S_IWRITE: Int32 { return Int32(0x0080) } public var S_IEXEC: Int32 { return Int32(0x0040) } -#else +#elseif !os(Android) public var S_IFMT: mode_t { return mode_t(0o170000) } public var S_IFIFO: mode_t { return mode_t(0o010000) } public var S_IFCHR: mode_t { return mode_t(0o020000) } diff --git a/stdlib/public/RegexBuilder/CMakeLists.txt b/stdlib/public/RegexBuilder/CMakeLists.txt index 8db5dae116602..117cb57ee7f60 100644 --- a/stdlib/public/RegexBuilder/CMakeLists.txt +++ b/stdlib/public/RegexBuilder/CMakeLists.txt @@ -27,6 +27,7 @@ message(STATUS "Using Experimental String Processing library for RegexBuilder ($ add_swift_target_library(swiftRegexBuilder ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB "${REGEX_BUILDER_SOURCES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc diff --git a/stdlib/public/StringProcessing/CMakeLists.txt b/stdlib/public/StringProcessing/CMakeLists.txt index 408e019e46644..c767dcff59f42 100644 --- a/stdlib/public/StringProcessing/CMakeLists.txt +++ b/stdlib/public/StringProcessing/CMakeLists.txt @@ -41,6 +41,7 @@ message(STATUS "Using Experimental String Processing library for _StringProcessi add_swift_target_library(swift_StringProcessing ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB "${STRING_PROCESSING_SOURCES}" + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_MODULE_DEPENDS_LINUX Glibc SWIFT_MODULE_DEPENDS_FREEBSD Glibc SWIFT_MODULE_DEPENDS_OPENBSD Glibc From 0f9a69c712a5dc6eb891389447f7a55abf9b051e Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Fri, 3 May 2024 18:00:38 -0700 Subject: [PATCH 03/15] android test fixes --- test/AutoDiff/SILOptimizer/pullback_inlining.swift | 2 ++ .../issue-56600-symbol-in-ir-file-not-tbd-file.swift | 2 ++ test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb | 2 ++ test/AutoDiff/validation-test/custom_derivatives.swift | 2 ++ test/AutoDiff/validation-test/separate_tangent_type.swift | 2 ++ test/ClangImporter/clang_builtins.swift | 2 ++ test/Concurrency/Runtime/async.swift | 2 ++ .../Runtime/async_task_locals_copy_to_sync.swift | 2 ++ .../Runtime/async_task_withUnsafeCurrentTask.swift | 4 +++- test/Concurrency/Runtime/cancellation_handler.swift | 2 ++ test/Concurrency/Runtime/data_race_detection_crash.swift | 2 ++ .../Runtime/data_race_detection_legacy_warning.swift | 2 ++ test/Concurrency/Runtime/exclusivity.swift | 2 ++ test/Concurrency/Runtime/exclusivity_custom_executors.swift | 2 ++ test/Concurrency/Runtime/executor_deinit3.swift | 2 ++ test/Concurrency/async_task_base_priority.swift | 2 ++ test/IRGen/builtin_math.swift | 2 ++ test/IRGen/sanitize_coverage.swift | 2 ++ test/Interop/Cxx/libc/include-glibc.swift | 6 ++++++ test/Interpreter/dynamicReplacement_property_observer.swift | 2 ++ test/Interpreter/dynamic_replacement.swift | 2 ++ test/Interpreter/dynamic_replacement_chaining.swift | 2 ++ .../dynamic_replacement_without_previous_calls.swift | 2 ++ test/Prototypes/BigInt.swift | 2 ++ test/SILOptimizer/c_string_optimization.swift | 2 ++ test/multifile/protocol-conformance-redundant.swift | 2 ++ test/stdlib/FloatConstants.swift | 2 ++ test/stdlib/MathConstants.swift | 2 ++ test/stdlib/POSIX.swift | 2 ++ test/stdlib/PrintFloat.swift.gyb | 2 ++ test/stdlib/Runtime.swift.gyb | 2 ++ test/stdlib/VarArgs.swift | 3 +++ test/stdlib/mmap.swift | 4 ++++ test/stdlib/tgmath_optimized.swift | 2 ++ 34 files changed, 76 insertions(+), 1 deletion(-) diff --git a/test/AutoDiff/SILOptimizer/pullback_inlining.swift b/test/AutoDiff/SILOptimizer/pullback_inlining.swift index 431dd98064f58..fc0cc7f9f14f9 100644 --- a/test/AutoDiff/SILOptimizer/pullback_inlining.swift +++ b/test/AutoDiff/SILOptimizer/pullback_inlining.swift @@ -9,6 +9,8 @@ import _Differentiation #if canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #else import Foundation #endif diff --git a/test/AutoDiff/compiler_crashers_fixed/issue-56600-symbol-in-ir-file-not-tbd-file.swift b/test/AutoDiff/compiler_crashers_fixed/issue-56600-symbol-in-ir-file-not-tbd-file.swift index fe65a165c4f53..7a5e395dd6551 100644 --- a/test/AutoDiff/compiler_crashers_fixed/issue-56600-symbol-in-ir-file-not-tbd-file.swift +++ b/test/AutoDiff/compiler_crashers_fixed/issue-56600-symbol-in-ir-file-not-tbd-file.swift @@ -12,6 +12,8 @@ import _Differentiation import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb b/test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb index 39535f5f1fb55..a4a81a6a28ac8 100644 --- a/test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb +++ b/test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb @@ -5,6 +5,8 @@ import Darwin.C.tgmath #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/AutoDiff/validation-test/custom_derivatives.swift b/test/AutoDiff/validation-test/custom_derivatives.swift index f28a233dd34b6..233c5819f40dd 100644 --- a/test/AutoDiff/validation-test/custom_derivatives.swift +++ b/test/AutoDiff/validation-test/custom_derivatives.swift @@ -6,6 +6,8 @@ import StdlibUnittest import Darwin.C #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/AutoDiff/validation-test/separate_tangent_type.swift b/test/AutoDiff/validation-test/separate_tangent_type.swift index 3770e240777e6..87796d5da6b5a 100644 --- a/test/AutoDiff/validation-test/separate_tangent_type.swift +++ b/test/AutoDiff/validation-test/separate_tangent_type.swift @@ -6,6 +6,8 @@ import StdlibUnittest import Darwin.C #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/ClangImporter/clang_builtins.swift b/test/ClangImporter/clang_builtins.swift index 4b73e96a45be1..24b83bcd6abd8 100644 --- a/test/ClangImporter/clang_builtins.swift +++ b/test/ClangImporter/clang_builtins.swift @@ -4,6 +4,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/test/Concurrency/Runtime/async.swift b/test/Concurrency/Runtime/async.swift index ad787c0d874ea..965819cbdf078 100644 --- a/test/Concurrency/Runtime/async.swift +++ b/test/Concurrency/Runtime/async.swift @@ -16,6 +16,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #endif var asyncTests = TestSuite("Async") diff --git a/test/Concurrency/Runtime/async_task_locals_copy_to_sync.swift b/test/Concurrency/Runtime/async_task_locals_copy_to_sync.swift index c0f7bda2805d7..bdb37734d35c0 100644 --- a/test/Concurrency/Runtime/async_task_locals_copy_to_sync.swift +++ b/test/Concurrency/Runtime/async_task_locals_copy_to_sync.swift @@ -18,6 +18,8 @@ import Dispatch import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #endif enum TL { diff --git a/test/Concurrency/Runtime/async_task_withUnsafeCurrentTask.swift b/test/Concurrency/Runtime/async_task_withUnsafeCurrentTask.swift index 8ac4ad2f1579e..d22049945b751 100644 --- a/test/Concurrency/Runtime/async_task_withUnsafeCurrentTask.swift +++ b/test/Concurrency/Runtime/async_task_withUnsafeCurrentTask.swift @@ -10,6 +10,8 @@ import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) +import Android #else import Darwin #endif @@ -36,4 +38,4 @@ func test_withUnsafeCurrentTask() async { static func main() async { await test_withUnsafeCurrentTask() } -} \ No newline at end of file +} diff --git a/test/Concurrency/Runtime/cancellation_handler.swift b/test/Concurrency/Runtime/cancellation_handler.swift index ba221c8592687..3cefaa5134469 100644 --- a/test/Concurrency/Runtime/cancellation_handler.swift +++ b/test/Concurrency/Runtime/cancellation_handler.swift @@ -12,6 +12,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif canImport(WASILibc) import WASILibc #elseif os(Windows) diff --git a/test/Concurrency/Runtime/data_race_detection_crash.swift b/test/Concurrency/Runtime/data_race_detection_crash.swift index 47238ede23127..2ab3ec805aa46 100644 --- a/test/Concurrency/Runtime/data_race_detection_crash.swift +++ b/test/Concurrency/Runtime/data_race_detection_crash.swift @@ -24,6 +24,8 @@ import Dispatch import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #endif @MainActor func onMainActor() { diff --git a/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift b/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift index dc891057d22f2..d1ff97c0abb8c 100644 --- a/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift +++ b/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift @@ -25,6 +25,8 @@ import Dispatch import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #endif @MainActor func onMainActor() { diff --git a/test/Concurrency/Runtime/exclusivity.swift b/test/Concurrency/Runtime/exclusivity.swift index 7e07776900f35..6bd44273e6bb0 100644 --- a/test/Concurrency/Runtime/exclusivity.swift +++ b/test/Concurrency/Runtime/exclusivity.swift @@ -31,6 +31,8 @@ var global3: Int = 7 import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #elseif canImport(CRT) import CRT #endif diff --git a/test/Concurrency/Runtime/exclusivity_custom_executors.swift b/test/Concurrency/Runtime/exclusivity_custom_executors.swift index 5e5d62fe495c1..f9f44d87aa6ec 100644 --- a/test/Concurrency/Runtime/exclusivity_custom_executors.swift +++ b/test/Concurrency/Runtime/exclusivity_custom_executors.swift @@ -26,6 +26,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #elseif canImport(CRT) import CRT #endif diff --git a/test/Concurrency/Runtime/executor_deinit3.swift b/test/Concurrency/Runtime/executor_deinit3.swift index 302ab4c67e91c..f6063c985157b 100644 --- a/test/Concurrency/Runtime/executor_deinit3.swift +++ b/test/Concurrency/Runtime/executor_deinit3.swift @@ -14,6 +14,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #endif @available(SwiftStdlib 5.1, *) diff --git a/test/Concurrency/async_task_base_priority.swift b/test/Concurrency/async_task_base_priority.swift index 76febb58c5887..763ef3ad14a14 100644 --- a/test/Concurrency/async_task_base_priority.swift +++ b/test/Concurrency/async_task_base_priority.swift @@ -21,6 +21,8 @@ import Dispatch import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #elseif os(WASI) import WASILibc #elseif os(Windows) diff --git a/test/IRGen/builtin_math.swift b/test/IRGen/builtin_math.swift index 3426c1ee085c4..a9092de3d2195 100644 --- a/test/IRGen/builtin_math.swift +++ b/test/IRGen/builtin_math.swift @@ -6,6 +6,8 @@ import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/IRGen/sanitize_coverage.swift b/test/IRGen/sanitize_coverage.swift index af28df7424155..e7090acaab692 100644 --- a/test/IRGen/sanitize_coverage.swift +++ b/test/IRGen/sanitize_coverage.swift @@ -15,6 +15,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/Interop/Cxx/libc/include-glibc.swift b/test/Interop/Cxx/libc/include-glibc.swift index 2d1dcdc6ea227..37a7ace641f36 100644 --- a/test/Interop/Cxx/libc/include-glibc.swift +++ b/test/Interop/Cxx/libc/include-glibc.swift @@ -3,7 +3,13 @@ // REQUIRES: executable_test // REQUIRES: OS=linux-gnu || OS=linux-android +#if canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android +#else +#error ("unsupported platform") +#endif import StdlibUnittest var GlibcTests = TestSuite("GlibcTests") diff --git a/test/Interpreter/dynamicReplacement_property_observer.swift b/test/Interpreter/dynamicReplacement_property_observer.swift index 9c3313e36c144..bbf47ecf410fe 100644 --- a/test/Interpreter/dynamicReplacement_property_observer.swift +++ b/test/Interpreter/dynamicReplacement_property_observer.swift @@ -17,6 +17,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT import WinSDK diff --git a/test/Interpreter/dynamic_replacement.swift b/test/Interpreter/dynamic_replacement.swift index 80f572e634fce..426532a1951d5 100644 --- a/test/Interpreter/dynamic_replacement.swift +++ b/test/Interpreter/dynamic_replacement.swift @@ -109,6 +109,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT import WinSDK diff --git a/test/Interpreter/dynamic_replacement_chaining.swift b/test/Interpreter/dynamic_replacement_chaining.swift index bd5579ed88528..940a361072bd2 100644 --- a/test/Interpreter/dynamic_replacement_chaining.swift +++ b/test/Interpreter/dynamic_replacement_chaining.swift @@ -30,6 +30,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT import WinSDK diff --git a/test/Interpreter/dynamic_replacement_without_previous_calls.swift b/test/Interpreter/dynamic_replacement_without_previous_calls.swift index a9dc7254d836a..233f52a6aa572 100644 --- a/test/Interpreter/dynamic_replacement_without_previous_calls.swift +++ b/test/Interpreter/dynamic_replacement_without_previous_calls.swift @@ -16,6 +16,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT import WinSDK diff --git a/test/Prototypes/BigInt.swift b/test/Prototypes/BigInt.swift index 532f926bffb7b..ca7725cede255 100644 --- a/test/Prototypes/BigInt.swift +++ b/test/Prototypes/BigInt.swift @@ -22,6 +22,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/SILOptimizer/c_string_optimization.swift b/test/SILOptimizer/c_string_optimization.swift index f859063c77d6d..2173bd0b4d122 100644 --- a/test/SILOptimizer/c_string_optimization.swift +++ b/test/SILOptimizer/c_string_optimization.swift @@ -10,6 +10,8 @@ import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/multifile/protocol-conformance-redundant.swift b/test/multifile/protocol-conformance-redundant.swift index f27a8a346b5d6..9a8814221e264 100644 --- a/test/multifile/protocol-conformance-redundant.swift +++ b/test/multifile/protocol-conformance-redundant.swift @@ -17,6 +17,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) +import Android #else #error("Unsupported platform") #endif diff --git a/test/stdlib/FloatConstants.swift b/test/stdlib/FloatConstants.swift index 3ed928a9d8848..04762a18eafe7 100644 --- a/test/stdlib/FloatConstants.swift +++ b/test/stdlib/FloatConstants.swift @@ -6,6 +6,8 @@ import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/stdlib/MathConstants.swift b/test/stdlib/MathConstants.swift index 9cc0cd776a07f..9a6c0857c509c 100644 --- a/test/stdlib/MathConstants.swift +++ b/test/stdlib/MathConstants.swift @@ -6,6 +6,8 @@ import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/stdlib/POSIX.swift b/test/stdlib/POSIX.swift index c60aa771c0000..42b9edb5f4123 100644 --- a/test/stdlib/POSIX.swift +++ b/test/stdlib/POSIX.swift @@ -9,6 +9,8 @@ import SwiftPrivateLibcExtras import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/test/stdlib/PrintFloat.swift.gyb b/test/stdlib/PrintFloat.swift.gyb index 78d51cd67abae..984201b45b48e 100644 --- a/test/stdlib/PrintFloat.swift.gyb +++ b/test/stdlib/PrintFloat.swift.gyb @@ -19,6 +19,8 @@ import SwiftPrivateLibcExtras import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT #else diff --git a/test/stdlib/Runtime.swift.gyb b/test/stdlib/Runtime.swift.gyb index c4f872f1961e7..e58c939c5f6f9 100644 --- a/test/stdlib/Runtime.swift.gyb +++ b/test/stdlib/Runtime.swift.gyb @@ -17,6 +17,8 @@ import SwiftShims import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT import WinSDK diff --git a/test/stdlib/VarArgs.swift b/test/stdlib/VarArgs.swift index 139f66c8bfb90..b3f65d0bd6b03 100644 --- a/test/stdlib/VarArgs.swift +++ b/test/stdlib/VarArgs.swift @@ -27,6 +27,9 @@ runAllTests() #elseif os(WASI) import WASILibc typealias CGFloat = Double +#elseif canImport(Android) + import Android + typealias CGFloat = Double #elseif os(Windows) import CRT #if arch(x86_64) || arch(arm64) diff --git a/test/stdlib/mmap.swift b/test/stdlib/mmap.swift index cf335bf81810f..2695875543911 100644 --- a/test/stdlib/mmap.swift +++ b/test/stdlib/mmap.swift @@ -8,6 +8,10 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android + // MAP_FAILED is not available on android. + let MAP_FAILED = UnsafeMutableRawPointer(bitPattern: -1) #else #error("Unsupported platform") #endif diff --git a/test/stdlib/tgmath_optimized.swift b/test/stdlib/tgmath_optimized.swift index 1d6de6ba3b7ee..ab57a6ddd80eb 100644 --- a/test/stdlib/tgmath_optimized.swift +++ b/test/stdlib/tgmath_optimized.swift @@ -10,6 +10,8 @@ import Glibc #elseif os(WASI) import WASILibc +#elseif os(Android) + import Android #elseif os(Windows) import CRT #else From 420e03fca66dff8163a423da460332e28ce6c612 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Wed, 8 May 2024 22:28:45 -0700 Subject: [PATCH 04/15] add one more concurrency test fix --- .../Runtime/data_race_detection_legacy_warning.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift b/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift index d1ff97c0abb8c..d7c270be925c4 100644 --- a/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift +++ b/test/Concurrency/Runtime/data_race_detection_legacy_warning.swift @@ -68,14 +68,14 @@ actor MyActor { struct Runner { static func main() async { print("Launching a main-actor task") - // CHECK: data race detected: @MainActor function at main/data_race_detection_legacy_warning.swift:30 was not called on the main thread + // CHECK: data race detected: @MainActor function at main/data_race_detection_legacy_warning.swift:32 was not called on the main thread launchFromMainThread() sleep(1) let actor = MyActor() let actorFn = await actor.getTaskOnMyActor() print("Launching an actor-instance task") - // CHECK: data race detected: actor-isolated function at main/data_race_detection_legacy_warning.swift:59 was not called on the same actor + // CHECK: data race detected: actor-isolated function at main/data_race_detection_legacy_warning.swift:61 was not called on the same actor launchTask(actorFn) sleep(1) From 95209ca4684cc8c485fa31303600702c81dfa3b9 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Wed, 8 May 2024 22:41:54 -0700 Subject: [PATCH 05/15] update tests to use canImport(android) and make libc test for generalized --- test/IRGen/builtin_math.swift | 2 +- .../Cxx/libc/{include-glibc.swift => include-libc.swift} | 4 ++-- test/stdlib/FloatConstants.swift | 2 +- test/stdlib/MathConstants.swift | 2 +- test/stdlib/PrintFloat.swift.gyb | 2 +- test/stdlib/Runtime.swift.gyb | 2 +- test/stdlib/tgmath_optimized.swift | 2 +- 7 files changed, 8 insertions(+), 8 deletions(-) rename test/Interop/Cxx/libc/{include-glibc.swift => include-libc.swift} (83%) diff --git a/test/IRGen/builtin_math.swift b/test/IRGen/builtin_math.swift index a9092de3d2195..956b2e2e0c5b2 100644 --- a/test/IRGen/builtin_math.swift +++ b/test/IRGen/builtin_math.swift @@ -6,7 +6,7 @@ import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT diff --git a/test/Interop/Cxx/libc/include-glibc.swift b/test/Interop/Cxx/libc/include-libc.swift similarity index 83% rename from test/Interop/Cxx/libc/include-glibc.swift rename to test/Interop/Cxx/libc/include-libc.swift index 37a7ace641f36..807e5681cc558 100644 --- a/test/Interop/Cxx/libc/include-glibc.swift +++ b/test/Interop/Cxx/libc/include-libc.swift @@ -12,9 +12,9 @@ import Android #endif import StdlibUnittest -var GlibcTests = TestSuite("GlibcTests") +var LibcTests = TestSuite("LibcTests") -GlibcTests.test("abs") { +LibcTests.test("abs") { expectEqual(42, abs(-42)) } diff --git a/test/stdlib/FloatConstants.swift b/test/stdlib/FloatConstants.swift index 04762a18eafe7..0067e7df79cb0 100644 --- a/test/stdlib/FloatConstants.swift +++ b/test/stdlib/FloatConstants.swift @@ -6,7 +6,7 @@ import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT diff --git a/test/stdlib/MathConstants.swift b/test/stdlib/MathConstants.swift index 9a6c0857c509c..1ff5c0d6a5b94 100644 --- a/test/stdlib/MathConstants.swift +++ b/test/stdlib/MathConstants.swift @@ -6,7 +6,7 @@ import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif CanImport(Android) import Android #elseif os(Windows) import CRT diff --git a/test/stdlib/PrintFloat.swift.gyb b/test/stdlib/PrintFloat.swift.gyb index 984201b45b48e..5377a6d2b2467 100644 --- a/test/stdlib/PrintFloat.swift.gyb +++ b/test/stdlib/PrintFloat.swift.gyb @@ -19,7 +19,7 @@ import SwiftPrivateLibcExtras import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT diff --git a/test/stdlib/Runtime.swift.gyb b/test/stdlib/Runtime.swift.gyb index e58c939c5f6f9..6d5ef26e90559 100644 --- a/test/stdlib/Runtime.swift.gyb +++ b/test/stdlib/Runtime.swift.gyb @@ -17,7 +17,7 @@ import SwiftShims import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT diff --git a/test/stdlib/tgmath_optimized.swift b/test/stdlib/tgmath_optimized.swift index ab57a6ddd80eb..369a7e8ab1266 100644 --- a/test/stdlib/tgmath_optimized.swift +++ b/test/stdlib/tgmath_optimized.swift @@ -10,7 +10,7 @@ import Glibc #elseif os(WASI) import WASILibc -#elseif os(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT From a99b3748fe3b9f1a67a5afa1102787d6628e5533 Mon Sep 17 00:00:00 2001 From: Finagolfin Date: Sun, 12 May 2024 20:49:19 +0530 Subject: [PATCH 06/15] [android] Update tests to use new Android overlay and disable stdlib/Glibc.swift --- .../ChildProcessShutdown/FailIfChildCrashesDuringShutdown.swift | 2 ++ .../ChildProcessShutdown/FailIfChildExitsDuringShutdown.swift | 2 ++ .../PassIfChildCrashedDuringTestExecution.swift | 2 ++ .../StdlibUnittest/ChildProcessShutdown/RequireOwnProcess.swift | 2 ++ validation-test/StdlibUnittest/Stdin.swift | 2 ++ validation-test/stdlib/Glibc.swift | 2 +- validation-test/stdlib/POSIXErrorCode.swift | 2 ++ validation-test/stdlib/String.swift | 2 ++ 8 files changed, 15 insertions(+), 1 deletion(-) diff --git a/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildCrashesDuringShutdown.swift b/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildCrashesDuringShutdown.swift index b596a2015b9b3..0408bc81bf5ee 100644 --- a/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildCrashesDuringShutdown.swift +++ b/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildCrashesDuringShutdown.swift @@ -10,6 +10,8 @@ import StdlibUnittest import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildExitsDuringShutdown.swift b/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildExitsDuringShutdown.swift index 888274eb243d9..e024a0e070810 100644 --- a/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildExitsDuringShutdown.swift +++ b/validation-test/StdlibUnittest/ChildProcessShutdown/FailIfChildExitsDuringShutdown.swift @@ -8,6 +8,8 @@ import StdlibUnittest import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/StdlibUnittest/ChildProcessShutdown/PassIfChildCrashedDuringTestExecution.swift b/validation-test/StdlibUnittest/ChildProcessShutdown/PassIfChildCrashedDuringTestExecution.swift index 77af5601fd0be..8687bde2c1843 100644 --- a/validation-test/StdlibUnittest/ChildProcessShutdown/PassIfChildCrashedDuringTestExecution.swift +++ b/validation-test/StdlibUnittest/ChildProcessShutdown/PassIfChildCrashedDuringTestExecution.swift @@ -8,6 +8,8 @@ import StdlibUnittest import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/StdlibUnittest/ChildProcessShutdown/RequireOwnProcess.swift b/validation-test/StdlibUnittest/ChildProcessShutdown/RequireOwnProcess.swift index 2bfa62c5252bd..a74e4a25165d8 100644 --- a/validation-test/StdlibUnittest/ChildProcessShutdown/RequireOwnProcess.swift +++ b/validation-test/StdlibUnittest/ChildProcessShutdown/RequireOwnProcess.swift @@ -8,6 +8,8 @@ import StdlibUnittest import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/StdlibUnittest/Stdin.swift b/validation-test/StdlibUnittest/Stdin.swift index 056a92c9ca04e..a6c144e56eabd 100644 --- a/validation-test/StdlibUnittest/Stdin.swift +++ b/validation-test/StdlibUnittest/Stdin.swift @@ -10,6 +10,8 @@ import StdlibUnittest import Glibc #elseif os(Windows) import MSVCRT +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/stdlib/Glibc.swift b/validation-test/stdlib/Glibc.swift index 70276d29e0b81..1b004367078a8 100644 --- a/validation-test/stdlib/Glibc.swift +++ b/validation-test/stdlib/Glibc.swift @@ -6,7 +6,7 @@ // UNSUPPORTED: OS=tvos // UNSUPPORTED: OS=watchos -// REQUIRES: OS=linux-gnu || OS=linux-androideabi || OS=linux-android +// REQUIRES: OS=linux-gnu import Swift import StdlibUnittest diff --git a/validation-test/stdlib/POSIXErrorCode.swift b/validation-test/stdlib/POSIXErrorCode.swift index 2d3a442cd125e..5f126a314ffcb 100644 --- a/validation-test/stdlib/POSIXErrorCode.swift +++ b/validation-test/stdlib/POSIXErrorCode.swift @@ -10,6 +10,8 @@ import StdlibUnittest import Darwin #elseif canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #else #error("Unsupported platform") #endif diff --git a/validation-test/stdlib/String.swift b/validation-test/stdlib/String.swift index 32de3fa68542c..cc2219af7e73f 100644 --- a/validation-test/stdlib/String.swift +++ b/validation-test/stdlib/String.swift @@ -1235,6 +1235,8 @@ StringTests.test("Conversions") { #if canImport(Glibc) import Glibc +#elseif canImport(Android) + import Android #endif StringTests.test("lowercased()") { From d7de7c69cab6cd544b4a165705c1576634ae5a14 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Sun, 26 May 2024 20:08:41 -0700 Subject: [PATCH 07/15] Fix canImport android --- stdlib/public/Differentiation/TgmathDerivatives.swift.gyb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb b/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb index ce28c9c5d079f..52600d71be9ee 100644 --- a/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb +++ b/stdlib/public/Differentiation/TgmathDerivatives.swift.gyb @@ -24,7 +24,7 @@ import Swift import WASILibc #elseif os(Windows) import CRT -#elseif os(Android) +#elseif canImport(Android) import Android #else #error("Unsupported platform") From 607766299bb2bd309ca413aa9ab450bdf3ea5ec5 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 28 May 2024 12:53:15 -0700 Subject: [PATCH 08/15] drop android stuff --- stdlib/public/Platform/Android.swift | 75 ---------------------------- 1 file changed, 75 deletions(-) diff --git a/stdlib/public/Platform/Android.swift b/stdlib/public/Platform/Android.swift index 32f71ebdd9b08..cb15c356a8d12 100644 --- a/stdlib/public/Platform/Android.swift +++ b/stdlib/public/Platform/Android.swift @@ -11,78 +11,3 @@ //===----------------------------------------------------------------------===// @_exported import SwiftAndroid // Clang module - -@available(swift, deprecated: 3.0, message: "Please use 'Double.pi' or '.pi' to get the value of correct type and avoid casting.") -public let M_PI = Double.pi -@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 2' or '.pi / 2' to get the value of correct type and avoid casting.") -public let M_PI_2 = Double.pi / 2 -@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 4' or '.pi / 4' to get the value of correct type and avoid casting.") -public let M_PI_4 = Double.pi / 4 - -@available(swift, deprecated: 3.0, message: "Please use 2.squareRoot()'.") -public let M_SQRT2 = 2.squareRoot() - -@available(swift, deprecated: 3.0, message: "Please use 0.5.squareRoot()'.") -public let M_SQRT1_2 = 0.5.squareRoot() - -@available(swift, deprecated: 3.0, message: "Please use 'T.radix' to get the radix of a FloatingPoint type 'T'.") -public let FLT_RADIX = Double.radix - -// Where does the 1 come from? C counts the usually-implicit leading -// significand bit, but Swift does not. Neither is really right or wrong. -@available(swift, deprecated: 3.0, message: "Please use 'Float.significandBitCount + 1'.") -public let FLT_MANT_DIG = Float.significandBitCount + 1 - -// Where does the 1 come from? C models floating-point numbers as having a -// significand in [0.5, 1), but Swift (following IEEE 754) considers the -// significand to be in [1, 2). This rationale applies to FLT_MIN_EXP -// as well. -@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude.exponent + 1'.") -public let FLT_MAX_EXP = Float.greatestFiniteMagnitude.exponent + 1 - -@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude.exponent + 1'.") -public let FLT_MIN_EXP = Float.leastNormalMagnitude.exponent + 1 - -@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.") -public let FLT_MAX = Float.greatestFiniteMagnitude - -@available(swift, deprecated: 3.0, message: "Please use 'Float.ulpOfOne' or '.ulpOfOne'.") -public let FLT_EPSILON = Float.ulpOfOne - -@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude' or '.leastNormalMagnitude'.") -public let FLT_MIN = Float.leastNormalMagnitude - -@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.") -public let FLT_TRUE_MIN = Float.leastNonzeroMagnitude - - -// Where does the 1 come from? C counts the usually-implicit leading -// significand bit, but Swift does not. Neither is really right or wrong. -@available(swift, deprecated: 3.0, message: "Please use 'Double.significandBitCount + 1'.") -public let DBL_MANT_DIG = Double.significandBitCount + 1 - -// Where does the 1 come from? C models floating-point numbers as having a -// significand in [0.5, 1), but Swift (following IEEE 754) considers the -// significand to be in [1, 2). This rationale applies to DBL_MIN_EXP -// as well. -@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude.exponent + 1'.") -public let DBL_MAX_EXP = Double.greatestFiniteMagnitude.exponent + 1 - -@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude.exponent + 1'.") -public let DBL_MIN_EXP = Double.leastNormalMagnitude.exponent + 1 - -@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.") -public let DBL_MAX = Double.greatestFiniteMagnitude - -@available(swift, deprecated: 3.0, message: "Please use 'Double.ulpOfOne' or '.ulpOfOne'.") -public let DBL_EPSILON = Double.ulpOfOne - -@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude' or '.leastNormalMagnitude'.") -public let DBL_MIN = Double.leastNormalMagnitude - -@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.") -public let DBL_TRUE_MIN = Double.leastNonzeroMagnitude - -public let M_LN2 = SwiftAndroid.M_LN2 -public let M_LOG10E = SwiftAndroid.M_LOG10E -public let M_2_SQRTPI = SwiftAndroid.M_2_SQRTPI From 664f3329947dbfd199c72b6511240bf2ccfc245e Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 28 May 2024 08:57:11 -0700 Subject: [PATCH 09/15] Android: do not re-export macros from linux/stat.h from other modules This lets us declare constants in the Android platform module using the expected mode_t type --- stdlib/public/Platform/Platform.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/public/Platform/Platform.swift b/stdlib/public/Platform/Platform.swift index b6316445ee573..0c2d63a0cffdb 100644 --- a/stdlib/public/Platform/Platform.swift +++ b/stdlib/public/Platform/Platform.swift @@ -241,7 +241,7 @@ public var S_IFIFO: Int32 { return Int32(0x1000) } public var S_IREAD: Int32 { return Int32(0x0100) } public var S_IWRITE: Int32 { return Int32(0x0080) } public var S_IEXEC: Int32 { return Int32(0x0040) } -#elseif !os(Android) +#else public var S_IFMT: mode_t { return mode_t(0o170000) } public var S_IFIFO: mode_t { return mode_t(0o010000) } public var S_IFCHR: mode_t { return mode_t(0o020000) } From 86ba2513b07f162059914285161112d32147c317 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Fri, 31 May 2024 11:15:18 -0400 Subject: [PATCH 10/15] fix canImport clause in the MathConstants.swift testcase --- test/stdlib/MathConstants.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/stdlib/MathConstants.swift b/test/stdlib/MathConstants.swift index 1ff5c0d6a5b94..bef16ab430d6b 100644 --- a/test/stdlib/MathConstants.swift +++ b/test/stdlib/MathConstants.swift @@ -6,7 +6,7 @@ import Glibc #elseif os(WASI) import WASILibc -#elseif CanImport(Android) +#elseif canImport(Android) import Android #elseif os(Windows) import CRT From 8b8c72acd8b6f2acec1b4567b173d996a181f853 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 4 Jun 2024 12:30:46 -0700 Subject: [PATCH 11/15] [stdlib] add a _math module overlay for Android for deprecated constants --- stdlib/public/Platform/CMakeLists.txt | 14 ++++++++++++++ stdlib/public/Platform/Math.swift | 17 +++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 stdlib/public/Platform/Math.swift diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index 23ddb0a20857c..c04fa18640460 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -273,6 +273,20 @@ add_custom_target(musl_modulemap DEPENDS ${musl_modulemap_target_list}) set_property(TARGET musl_modulemap PROPERTY FOLDER "Miscellaneous") add_dependencies(sdk-overlay musl_modulemap) +# Add a system 'math' module overlay, that only applies only to platforms that +# have a top level '_math' module. +add_swift_target_library(swift_math ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY + Math.swift + + SWIFT_COMPILE_FLAGS + ${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS} + ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS} + ${swift_platform_compile_flags} + LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}" + TARGET_SDKS "ANDROID" + INSTALL_IN_COMPONENT sdk-overlay + DEPENDS android_modulemap) + add_swift_target_library(swiftAndroid ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY Android.swift ${swift_platform_sources} diff --git a/stdlib/public/Platform/Math.swift b/stdlib/public/Platform/Math.swift new file mode 100644 index 0000000000000..545a6cca36a89 --- /dev/null +++ b/stdlib/public/Platform/Math.swift @@ -0,0 +1,17 @@ +@_exported import _math + +// Constants defined by +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi' or '.pi' to get the value of correct type and avoid casting.") +public let M_PI = Double.pi + +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 2' or '.pi / 2' to get the value of correct type and avoid casting.") +public let M_PI_2 = Double.pi / 2 + +@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 4' or '.pi / 4' to get the value of correct type and avoid casting.") +public let M_PI_4 = Double.pi / 4 + +@available(swift, deprecated: 3.0, message: "Please use '2.squareRoot()'.") +public let M_SQRT2 = 2.squareRoot() + +@available(swift, deprecated: 3.0, message: "Please use '0.5.squareRoot()'.") +public let M_SQRT1_2 = 0.5.squareRoot() From 9c31f98f6fce1e8cf80c714c113edc52548c872c Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 4 Jun 2024 12:32:42 -0700 Subject: [PATCH 12/15] [cmake] fix android header name targets --- stdlib/public/Platform/CMakeLists.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index c04fa18640460..81b35abd59c16 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -430,7 +430,7 @@ if("ANDROID" IN_LIST SWIFT_SDKS) OUTPUT ${module_dir}/${android_modulemap_source} ${module_dir_static}/${android_modulemap_source} COMMENT "Copying Android modulemap to resource directories") add_custom_command_target( - copy_android_ndk_neader_resource + copy_android_ndk_header_resource COMMAND "${CMAKE_COMMAND}" "-E" "make_directory" ${module_dir} ${module_dir_static} COMMAND @@ -442,7 +442,7 @@ if("ANDROID" IN_LIST SWIFT_SDKS) OUTPUT ${module_dir}/${android_ndk_header_source} ${module_dir_static}/${android_ndk_header_source} COMMENT "Copying Android NDK header to resource directories") add_custom_command_target( - copy_android_bionic_neader_resource + copy_android_bionic_header_resource COMMAND "${CMAKE_COMMAND}" "-E" "make_directory" ${module_dir} ${module_dir_static} COMMAND @@ -455,11 +455,11 @@ if("ANDROID" IN_LIST SWIFT_SDKS) COMMENT "Copying Android NDK header to resource directories") add_dependencies(sdk-overlay ${copy_android_modulemap_resource} - ${copy_android_ndk_neader_resource} - ${copy_android_bionic_neader_resource}) + ${copy_android_ndk_header_resource} + ${copy_android_bionic_header_resource}) list(APPEND android_modulemap_target_list ${copy_android_modulemap_resource} - ${copy_android_ndk_neader_resource} - ${copy_android_bionic_neader_resource}) + ${copy_android_ndk_header_resource} + ${copy_android_bionic_header_resource}) swift_install_in_component(FILES "${android_modulemap_source}" "${android_ndk_header_source}" From e9739d7787cc5950d624757371c582321572cc63 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 4 Jun 2024 12:35:28 -0700 Subject: [PATCH 13/15] remove additional glibc android check from cmake --- stdlib/public/Platform/CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index 81b35abd59c16..9b875bced482e 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -367,8 +367,7 @@ foreach(sdk ${SWIFT_SDKS}) # If this SDK is a target for a non-native host, except if it's for Android # with its own native sysroot, create a native modulemap without a sysroot # prefix. This is the one we'll install instead. - if(NOT "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${arch}_PATH}" STREQUAL "/" AND - NOT (sdk STREQUAL "ANDROID" AND NOT "${SWIFT_ANDROID_NATIVE_SYSROOT}" STREQUAL "")) + if(NOT "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${arch}_PATH}" STREQUAL "/") set(glibc_sysroot_relative_modulemap_out "${module_dir}/sysroot-relative-modulemaps/glibc.modulemap") handle_gyb_source_single(glibc_modulemap_native_target From 273edcf2a2430fbb1a2271d562476c6cb9e133e1 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Tue, 4 Jun 2024 15:46:23 -0700 Subject: [PATCH 14/15] build CxxStdlib for Android too --- stdlib/public/Cxx/std/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/stdlib/public/Cxx/std/CMakeLists.txt b/stdlib/public/Cxx/std/CMakeLists.txt index 85087204882ae..be5807902e877 100644 --- a/stdlib/public/Cxx/std/CMakeLists.txt +++ b/stdlib/public/Cxx/std/CMakeLists.txt @@ -45,6 +45,7 @@ add_swift_target_library(swiftCxxStdlib STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_O SWIFT_MODULE_DEPENDS_WATCHOS ${swift_cxxstdlib_darwin_dependencies} SWIFT_MODULE_DEPENDS_XROS ${swift_cxxstdlib_darwin_dependencies} SWIFT_MODULE_DEPENDS_MACCATALYST ${swift_cxxstdlib_darwin_dependencies} + SWIFT_MODULE_DEPENDS_ANDROID Android SWIFT_COMPILE_FLAGS ${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS} ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS} -cxx-interoperability-mode=default @@ -56,7 +57,7 @@ add_swift_target_library(swiftCxxStdlib STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_O DEPLOYMENT_VERSION_OSX ${COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_OSX} LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}" - TARGET_SDKS ALL_APPLE_PLATFORMS LINUX WINDOWS + TARGET_SDKS ALL_APPLE_PLATFORMS LINUX WINDOWS ANDROID INSTALL_IN_COMPONENT compiler INSTALL_WITH_SHARED DEPENDS libstdcxx-modulemap libcxxshim_modulemap CxxStdlib-apinotes) From 743a501d1b79e32c1a9266ab45b259aaa1c17fa7 Mon Sep 17 00:00:00 2001 From: Alex Lorenz Date: Wed, 5 Jun 2024 10:52:08 -0700 Subject: [PATCH 15/15] comment cleanup --- stdlib/public/Platform/CMakeLists.txt | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index 9b875bced482e..7e709923ffcd0 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -273,7 +273,7 @@ add_custom_target(musl_modulemap DEPENDS ${musl_modulemap_target_list}) set_property(TARGET musl_modulemap PROPERTY FOLDER "Miscellaneous") add_dependencies(sdk-overlay musl_modulemap) -# Add a system 'math' module overlay, that only applies only to platforms that +# Add a system 'math' module overlay, which applies only to platforms that # have a top level '_math' module. add_swift_target_library(swift_math ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY Math.swift @@ -364,9 +364,8 @@ foreach(sdk ${SWIFT_SDKS}) ${copy_glibc_modulemap_header_static}) endif() - # If this SDK is a target for a non-native host, except if it's for Android - # with its own native sysroot, create a native modulemap without a sysroot - # prefix. This is the one we'll install instead. + # If this SDK is a target for a non-native host, create a native modulemap + # without a sysroot prefix. This is the one we'll install instead. if(NOT "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${arch}_PATH}" STREQUAL "/") set(glibc_sysroot_relative_modulemap_out "${module_dir}/sysroot-relative-modulemaps/glibc.modulemap")