| /* |
| * Copyright 2014-present Facebook, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| * not use this file except in compliance with the License. You may obtain |
| * a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package com.facebook.buck.android; |
| |
| import com.facebook.buck.cxx.CxxPlatform; |
| import com.facebook.buck.cxx.DebugPathSanitizer; |
| import com.facebook.buck.cxx.GnuLinker; |
| import com.facebook.buck.cxx.ImmutableCxxPlatform; |
| import com.facebook.buck.cxx.Linker; |
| import com.facebook.buck.cxx.Tool; |
| import com.facebook.buck.cxx.VersionedTool; |
| import com.facebook.buck.model.Flavor; |
| import com.facebook.buck.util.HumanReadableException; |
| import com.facebook.buck.util.environment.Platform; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.collect.ImmutableBiMap; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.io.Files; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.nio.charset.Charset; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| |
| public class NdkCxxPlatforms { |
| // Utility class, do not instantiate. |
| private NdkCxxPlatforms() { } |
| |
| /** |
| * The build toolchain, named (including compiler version) after the target platform/arch. |
| */ |
| public static enum Toolchain { |
| |
| X86_4_8("x86-4.8"), |
| ARM_LINUX_ADNROIDEABI_4_8("arm-linux-androideabi-4.8"), |
| ; |
| |
| private final String value; |
| |
| private Toolchain(String value) { |
| this.value = Preconditions.checkNotNull(value); |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| } |
| |
| /** |
| * The prefix used for tools built for the above toolchain. |
| */ |
| public static enum ToolchainPrefix { |
| |
| I686_LINUX_ANDROID("i686-linux-android"), |
| ARM_LINUX_ANDROIDEABI("arm-linux-androideabi"), |
| ; |
| |
| private final String value; |
| |
| private ToolchainPrefix(String value) { |
| this.value = Preconditions.checkNotNull(value); |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| } |
| |
| /** |
| * Name of the target CPU architecture. |
| */ |
| public static enum TargetArch { |
| |
| X86("x86"), |
| ARM("arm"), |
| ; |
| |
| private final String value; |
| |
| private TargetArch(String value) { |
| this.value = Preconditions.checkNotNull(value); |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| } |
| |
| /** |
| * Name of the target CPU + ABI. |
| */ |
| public static enum TargetArchAbi { |
| |
| X86("x86"), |
| ARMEABI("armeabi"), |
| ARMEABI_V7A("armeabi-v7a"), |
| ; |
| |
| private final String value; |
| |
| private TargetArchAbi(String value) { |
| this.value = Preconditions.checkNotNull(value); |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| } |
| |
| /** |
| * The OS and Architecture that we're building on. |
| */ |
| public static enum Host { |
| |
| DARWIN_X86_64("darwin-x86_64"), |
| LINUX_X86_64("linux-x86_64"), |
| WINDOWS_X86_64("windows-x86_64"), |
| ; |
| |
| private final String value; |
| |
| private Host(String value) { |
| this.value = Preconditions.checkNotNull(value); |
| } |
| |
| @Override |
| public String toString() { |
| return value; |
| } |
| |
| } |
| |
| /** |
| * The C/C++ runtime library to link against. |
| */ |
| public static enum CxxRuntime { |
| |
| SYSTEM("system", "system"), |
| GABIXX("gabi++_shared", "gabi++_static"), |
| STLPORT("stlport_shared", "stlport_static"), |
| GNUSTL("gnustl_shared", "gnustl_static"), |
| ; |
| |
| private final String sharedName; |
| private final String staticName; |
| |
| private CxxRuntime(String sharedName, String staticName) { |
| this.sharedName = sharedName; |
| this.staticName = staticName; |
| } |
| |
| public String getStaticName() { |
| return staticName; |
| } |
| |
| public String getSharedName() { |
| return sharedName; |
| } |
| |
| public String getSoname() { |
| return "lib" + sharedName + ".so"; |
| } |
| |
| } |
| |
| /** |
| * A container for all configuration settings needed to define a build target. |
| */ |
| public static class TargetConfiguration { |
| |
| public final Toolchain toolchain; |
| public final ToolchainPrefix toolchainPrefix; |
| public final TargetArch targetArch; |
| public final TargetArchAbi targetArchAbi; |
| public final String targetPlatform; |
| public final String compilerVersion; |
| public final ImmutableList<String> compilerFlags; |
| public final ImmutableList<String> linkerFlags; |
| |
| public TargetConfiguration( |
| Toolchain toolchain, |
| ToolchainPrefix toolchainPrefix, |
| TargetArch targetArch, |
| TargetArchAbi targetArchAbi, |
| String targetPlatform, |
| String compilerVersion, |
| ImmutableList<String> compilerFlags, |
| ImmutableList<String> linkerFlags) { |
| this.toolchain = Preconditions.checkNotNull(toolchain); |
| this.toolchainPrefix = Preconditions.checkNotNull(toolchainPrefix); |
| this.targetArch = Preconditions.checkNotNull(targetArch); |
| this.targetArchAbi = Preconditions.checkNotNull(targetArchAbi); |
| this.targetPlatform = Preconditions.checkNotNull(targetPlatform); |
| this.compilerVersion = Preconditions.checkNotNull(compilerVersion); |
| this.compilerFlags = Preconditions.checkNotNull(compilerFlags); |
| this.linkerFlags = Preconditions.checkNotNull(linkerFlags); |
| } |
| |
| } |
| |
| private static final ImmutableMap<Platform, Host> BUILD_PLATFORMS = |
| ImmutableMap.of( |
| Platform.LINUX, Host.LINUX_X86_64, |
| Platform.MACOS, Host.DARWIN_X86_64, |
| Platform.WINDOWS, Host.WINDOWS_X86_64); |
| |
| public static NdkCxxPlatform build( |
| Flavor flavor, |
| Platform platform, |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| CxxRuntime cxxRuntime) { |
| |
| String version = readVersion(ndkRoot); |
| |
| Host host = Preconditions.checkNotNull(BUILD_PLATFORMS.get(platform)); |
| |
| ImmutableCxxPlatform.Builder cxxPlatformBuilder = ImmutableCxxPlatform.builder(); |
| cxxPlatformBuilder |
| .setFlavor(flavor) |
| .setAs(getTool(ndkRoot, targetConfiguration, host, "as", version)) |
| // Default assembler flags added by the NDK to enforce the NX (no execute) security feature. |
| .addAsflags("--noexecstack") |
| .setAspp(getTool(ndkRoot, targetConfiguration, host, "gcc", version)) |
| .setCc(getTool(ndkRoot, targetConfiguration, host, "gcc", version)) |
| .addAllCflags(getCflagsInternal(targetConfiguration)) |
| .setCpp(getCppTool(ndkRoot, targetConfiguration, host, "gcc", version)) |
| .addAllCppflags(getCppflags(ndkRoot, targetConfiguration)) |
| .setCxx(getTool(ndkRoot, targetConfiguration, host, "g++", version)) |
| .addAllCxxflags(getCxxflagsInternal(targetConfiguration)) |
| .setCxxpp(getCppTool(ndkRoot, targetConfiguration, host, "g++", version)) |
| .addAllCxxppflags(getCxxppflags(ndkRoot, targetConfiguration)) |
| .setCxxld( |
| getCcLinkTool( |
| ndkRoot, |
| targetConfiguration, |
| host, |
| cxxRuntime, |
| "g++", |
| version)) |
| .addAllCxxldflags(targetConfiguration.linkerFlags) |
| .setLd( |
| new GnuLinker( |
| getTool( |
| ndkRoot, |
| targetConfiguration, |
| host, |
| "ld.gold", |
| version))) |
| // Default linker flags added by the NDK |
| .addLdflags( |
| // Enforce the NX (no execute) security feature |
| "-z", "noexecstack", |
| // Strip unused code |
| "--gc-sections", |
| // Forbid dangerous copy "relocations" |
| "-z", "nocopyreloc", |
| // We always pass the runtime library on the command line, so setting this flag |
| // means the resulting link will only use it if it was actually needed it. |
| "--as-needed") |
| .setAr(getTool(ndkRoot, targetConfiguration, host, "ar", version)) |
| .setDebugPathSanitizer( |
| Optional.of( |
| new DebugPathSanitizer( |
| 250, |
| File.separatorChar, |
| Paths.get("."), |
| ImmutableBiMap.of( |
| getNdkToolRoot(ndkRoot, targetConfiguration, host), |
| Paths.get("ANDROID_TOOLS_ROOT"), |
| ndkRoot, |
| Paths.get("ANDROID_NDK_ROOT"))))) |
| .setSharedLibraryExtension("so"); |
| |
| if (cxxRuntime != CxxRuntime.SYSTEM) { |
| cxxPlatformBuilder.putRuntimeLdflags( |
| Linker.LinkableDepType.SHARED, "-l" + cxxRuntime.getSharedName()); |
| cxxPlatformBuilder.putRuntimeLdflags( |
| Linker.LinkableDepType.STATIC, "-l" + cxxRuntime.getStaticName()); |
| } |
| |
| CxxPlatform cxxPlatform = cxxPlatformBuilder.build(); |
| |
| return ImmutableNdkCxxPlatform.builder() |
| .setCxxPlatform(cxxPlatform) |
| .setObjcopy(getToolPath(ndkRoot, targetConfiguration, host, "objcopy")) |
| .setCxxRuntime(cxxRuntime) |
| .setCxxSharedRuntimePath( |
| getCxxRuntimeDirectory(ndkRoot, targetConfiguration) |
| .resolve(cxxRuntime.getSoname())) |
| .build(); |
| } |
| |
| // Read the NDK version from the "RELEASE.TXT" at the NDK root. |
| private static String readVersion(Path ndkRoot) { |
| try { |
| return Files.readFirstLine( |
| ndkRoot.resolve("RELEASE.TXT").toFile(), |
| Charset.defaultCharset()).trim(); |
| } catch (IOException e) { |
| throw new HumanReadableException( |
| e, |
| "could not extract version from NDK repository at %s: %s", |
| ndkRoot, |
| e.getMessage()); |
| } |
| } |
| |
| private static Path getNdkToolRoot( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| Host host) { |
| return ndkRoot |
| .resolve("toolchains") |
| .resolve(targetConfiguration.toolchain.toString()) |
| .resolve("prebuilt") |
| .resolve(host.toString()); |
| } |
| |
| private static Path getToolPath( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| Host host, |
| String tool) { |
| return getNdkToolRoot(ndkRoot, targetConfiguration, host) |
| .resolve(targetConfiguration.toolchainPrefix.toString()) |
| .resolve("bin") |
| .resolve(tool); |
| } |
| |
| private static Tool getTool( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| Host host, |
| String tool, |
| String version) { |
| return new VersionedTool( |
| getToolPath(ndkRoot, targetConfiguration, host, tool), |
| ImmutableList.<String>of(), |
| tool, |
| targetConfiguration.toolchain.toString() + " " + version); |
| } |
| |
| private static Tool getCppTool( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| Host host, |
| String tool, |
| String version) { |
| return new VersionedTool( |
| getToolPath(ndkRoot, targetConfiguration, host, tool), |
| ImmutableList.of( |
| "-isystem", ndkRoot |
| .resolve("toolchains") |
| .resolve(targetConfiguration.toolchain.toString()) |
| .resolve("prebuilt") |
| .resolve(host.toString()) |
| .resolve("include") |
| .toString(), |
| "-isystem", ndkRoot |
| .resolve("toolchains") |
| .resolve(targetConfiguration.toolchain.toString()) |
| .resolve("prebuilt") |
| .resolve(host.toString()) |
| .resolve("lib") |
| .resolve("gcc") |
| .resolve(targetConfiguration.toolchainPrefix.toString()) |
| .resolve(targetConfiguration.compilerVersion) |
| .resolve("include") |
| .toString()), |
| tool, |
| targetConfiguration.toolchain.toString() + " " + version); |
| } |
| |
| private static Path getCxxRuntimeDirectory( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration) { |
| return ndkRoot |
| .resolve("sources") |
| .resolve("cxx-stl") |
| .resolve("gnu-libstdc++") |
| .resolve(targetConfiguration.compilerVersion) |
| .resolve("libs") |
| .resolve(targetConfiguration.targetArchAbi.toString()); |
| } |
| |
| private static Tool getCcLinkTool( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration, |
| Host host, |
| CxxRuntime cxxRuntime, |
| String tool, |
| String version) { |
| return new VersionedTool( |
| getToolPath(ndkRoot, targetConfiguration, host, tool), |
| ImmutableList.of( |
| "-B" + ndkRoot |
| .resolve("platforms") |
| .resolve(targetConfiguration.targetPlatform) |
| .resolve("arch-" + targetConfiguration.targetArch) |
| .resolve("usr") |
| .resolve("lib") |
| .toString(), |
| "-L" + getCxxRuntimeDirectory(ndkRoot, targetConfiguration).toString()), |
| tool, |
| targetConfiguration.toolchain.toString() + " " + version + " " + cxxRuntime.toString()); |
| } |
| |
| /** |
| * Flags to be used when either preprocessing or compiling C or C++ sources. |
| */ |
| private static ImmutableList<String> getCommonFlags() { |
| return ImmutableList.of( |
| // Enable default warnings and turn them into errors. |
| "-Wall", |
| "-Werror", |
| // NDK builds enable stack protector and debug symbols by default. |
| "-fstack-protector", |
| "-g3"); |
| } |
| |
| /** |
| * Flags to be used when either preprocessing or compiling C sources. |
| */ |
| private static ImmutableList<String> getCommonCFlags() { |
| return ImmutableList.of( |
| // Default to the newer C11 standard. This is *not* a default set in the NDK. |
| // Since this flag can be used multiple times, and because the compiler just uses |
| // whichever standard was specified last, cxx_library rules can override this from |
| // their BUCK-file definitions. |
| "-std=gnu11"); |
| } |
| |
| /** |
| * Flags to be used when either preprocessing or compiling C++ sources. |
| */ |
| private static ImmutableList<String> getCommonCxxFlags() { |
| return ImmutableList.of( |
| // Default to the newer C++11 standard. This is *not* a default set in the NDK. |
| // Since this flag can be used multiple times, and because the compiler just uses |
| // whichever standard was specified last, cxx_library rules can override this from |
| // their BUCK-file definitions. |
| "-std=gnu++11", |
| // By default, Android builds disable exceptions and runtime type identification. |
| "-fno-exceptions", |
| "-fno-rtti"); |
| } |
| |
| /** |
| * Flags to be used when preprocessing C or C++ sources. |
| */ |
| private static ImmutableList<String> getCommonPreprocessorFlags() { |
| return ImmutableList.of( |
| // Disable searching for headers provided by the system. This limits headers to just |
| // those provided by the NDK and any library dependencies. |
| "-nostdinc", |
| // Default macro definitions applied to all builds. |
| "-DNDEBUG", |
| "-DANDROID"); |
| } |
| |
| private static ImmutableList<String> getCommonIncludes( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration) { |
| return ImmutableList.of( |
| "-isystem", ndkRoot |
| .resolve("platforms") |
| .resolve(targetConfiguration.targetPlatform) |
| .resolve("arch-" + targetConfiguration.targetArch) |
| .resolve("usr") |
| .resolve("include") |
| .toString(), |
| "-isystem", ndkRoot |
| .resolve("platforms") |
| .resolve(targetConfiguration.targetPlatform) |
| .resolve("arch-" + targetConfiguration.targetArch) |
| .resolve("usr") |
| .resolve("include") |
| .resolve("linux") |
| .toString()); |
| } |
| |
| private static ImmutableList<String> getCppflags( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration) { |
| return ImmutableList.<String>builder() |
| .addAll(targetConfiguration.compilerFlags) |
| .addAll(getCommonPreprocessorFlags()) |
| .addAll(getCommonCFlags()) |
| .addAll(getCommonFlags()) |
| .addAll(getCommonIncludes(ndkRoot, targetConfiguration)) |
| .build(); |
| } |
| |
| private static ImmutableList<String> getCxxppflags( |
| Path ndkRoot, |
| TargetConfiguration targetConfiguration) { |
| return ImmutableList.<String>builder() |
| .addAll(targetConfiguration.compilerFlags) |
| .addAll(getCommonPreprocessorFlags()) |
| .addAll(getCommonCxxFlags()) |
| .addAll(getCommonFlags()) |
| .add("-Wno-literal-suffix") |
| .add( |
| "-isystem", |
| ndkRoot |
| .resolve("sources") |
| .resolve("cxx-stl") |
| .resolve("gnu-libstdc++") |
| .resolve(targetConfiguration.compilerVersion) |
| .resolve("include") |
| .toString()) |
| .add( |
| "-isystem", |
| ndkRoot |
| .resolve("sources") |
| .resolve("cxx-stl") |
| .resolve("gnu-libstdc++") |
| .resolve(targetConfiguration.compilerVersion) |
| .resolve("libs") |
| .resolve(targetConfiguration.targetArchAbi.toString()) |
| .resolve("include") |
| .toString()) |
| .addAll(getCommonIncludes(ndkRoot, targetConfiguration)) |
| .build(); |
| } |
| |
| /** |
| * Flags used when compiling either C or C++ sources. |
| */ |
| private static ImmutableList<String> getCommonCompilerFlags() { |
| return ImmutableList.of( |
| // Default compiler flags provided by the NDK build makefiles. |
| "-ffunction-sections", |
| "-funwind-tables", |
| "-fomit-frame-pointer", |
| "-fno-strict-aliasing"); |
| } |
| |
| private static ImmutableList<String> getCflagsInternal( |
| TargetConfiguration targetConfiguration) { |
| return ImmutableList.<String>builder() |
| .addAll(targetConfiguration.compilerFlags) |
| .addAll(getCommonCFlags()) |
| .addAll(getCommonFlags()) |
| .addAll(getCommonCompilerFlags()) |
| .build(); |
| } |
| |
| private static ImmutableList<String> getCxxflagsInternal( |
| TargetConfiguration targetConfiguration) { |
| return ImmutableList.<String>builder() |
| .addAll(targetConfiguration.compilerFlags) |
| .addAll(getCommonCxxFlags()) |
| .addAll(getCommonFlags()) |
| .addAll(getCommonCompilerFlags()) |
| .build(); |
| } |
| } |
