Merge pull request #1442 from SwiftAndroid/master · swiftlang/swift@728d21a

# The following only works with the Ninja generator in CMake >= 3.0.

set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING

"Define the maximum number of linker jobs for swift.")

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 passed 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.

# 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")

if("${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")

set(swift_can_crosscompile_stdlib FALSE)

else()

set(swift_can_crosscompile_stdlib TRUE)

endif()

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")

list(APPEND result

"-isysroot" "${SWIFT_SDK_${CFLAGS_SDK}_PATH}")

if("${CFLAGS_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")

# Check if there's a specific iOS deployment version needed for this invocation

"-fcoverage-mapping")

endif()

if("${CFLAGS_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("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)

endfunction()

elseif("${LFLAGS_SDK}" STREQUAL "FREEBSD")

list(APPEND result "-lpthread")

elseif("${LFLAGS_SDK}" STREQUAL "CYGWIN")

# NO extra libraries required.

# No extra libraries required.

elseif("${LFLAGS_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()

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")

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})

} else if (Target.isWatchOS()) {

Target.getOSVersion(major, minor, revision);

} else if (Target.isOSLinux() || Target.isOSFreeBSD() ||

Target.isOSWindows() ||

Target.isAndroid() || Target.isOSWindows() ||

Target.getTriple().empty())

{

major = minor = revision = 0;

"iOS",

"Linux",

"FreeBSD",

"Windows"

"Windows",

"Android"

};

static const StringRef SupportedConditionalCompilationArches[] = {

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())

if (triple.isOSDarwin())

return getPlatformNameForDarwin(getDarwinPlatformKind(triple));

if (triple.isAndroid())

return "android";

if (triple.isOSLinux())

return "linux";

// 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)

TC = new toolchains::Darwin(*this, Target);

break;

case llvm::Triple::Linux:

if (Target.isAndroid()) {

TC = new toolchains::Android(*this, Target);

} else {

TC = new toolchains::GenericUnix(*this, Target);

}

break;

case llvm::Triple::FreeBSD:

TC = new toolchains::GenericUnix(*this, Target);

break;

}

}

bool toolchains::GenericUnix::shouldProvideRPathToLinker() const {

return true;

std::string toolchains::GenericUnix::getTargetForLinker() const {

return getTriple().str();

}

bool toolchains::GenericUnix::shouldSpecifyTargetTripleToLinker() const {

bool toolchains::GenericUnix::shouldProvideRPathToLinker() const {

return true;

}

Arguments.push_back(context.Args.MakeArgString("-fuse-ld=" + Linker));

}

// Explicitly pass the target to the linker

if (shouldSpecifyTargetTripleToLinker()) {

Arguments.push_back(context.Args.MakeArgString("--target=" + getTriple().str()));

std::string Target = getTargetForLinker();

if (!Target.empty()) {

Arguments.push_back("-target");

Arguments.push_back(context.Args.MakeArgString(Target));

}

// Add the runtime library link path, which is platform-specific and found

return {"clang++", Arguments};

}

std::string

toolchains::Android::getTargetForLinker() const {

// Explicitly set the linker target to "androideabi", as opposed to the

// llvm::Triple representation of "armv7-none-linux-android".

// This is the only ABI we currently support for Android.

assert(

getTriple().getArch() == llvm::Triple::arm &&

getTriple().getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v7 &&

"Only armv7 targets are supported for Android");

return "armv7-none-linux-androideabi";

}

bool toolchains::Android::shouldProvideRPathToLinker() const {

return false;

}

std::string toolchains::Cygwin::getDefaultLinker() const {

// Cygwin uses the default BFD linker, even on ARM.

return "";

}

bool toolchains::Cygwin::shouldSpecifyTargetTripleToLinker() const {

return false;

std::string toolchains::Cygwin::getTargetForLinker() const {

return "";

}

std::string toolchains::Cygwin::getPreInputObjectPath(

/// and to not provide a specific linker otherwise.

virtual std::string getDefaultLinker() const;

/// The target to be passed to the compiler invocation. By default, this

/// is the target triple, but this may be overridden to accomodate some

/// platforms.

virtual std::string getTargetForLinker() const;

/// Whether to specify a linker -rpath to the Swift runtime library path.

/// -rpath is not supported on all platforms, and subclasses may override

/// this method to return false on platforms that don't support it. The

/// default is to return true (and so specify an -rpath).

virtual bool shouldProvideRPathToLinker() const;

/// Whether to explicitly specify the target triple as the linker

/// '--target'. This is not desirable on all platforms, and subclasses may

/// override this method to return false in those cases.

virtual bool shouldSpecifyTargetTripleToLinker() const;

/// Provides a path to an object that should be linked first. On platforms

/// that use ELF binaries, an object that provides markers and sizes for

/// metadata sections must be linked first. Platforms that do not need this

~GenericUnix() = default;

};

class LLVM_LIBRARY_VISIBILITY Android : public GenericUnix {

protected:

std::string getTargetForLinker() const override;

bool shouldProvideRPathToLinker() const override;

public:

Android(const Driver &D, const llvm::Triple &Triple) : GenericUnix(D, Triple) {}

~Android() = default;

};

class LLVM_LIBRARY_VISIBILITY Cygwin : public GenericUnix {

protected:

std::string getDefaultLinker() const override;

bool shouldSpecifyTargetTripleToLinker() const override;

std::string getTargetForLinker() const override;

std::string getPreInputObjectPath(

StringRef RuntimeLibraryPath) const override;