From e4d27636b388512a8f18d3a5ccf6ca2485a61a7f Mon Sep 17 00:00:00 2001 From: Jingwen Chen Date: Thu, 18 Apr 2019 18:07:11 -0400 Subject: [PATCH] WIP: NDK r19 support Change-Id: I39992ab5742e6acf6ffaf20ec68383d31e89ce84 --- .../ndkcrosstools/AndroidNdkCrosstools.java | 2 + .../r19/AndroidNdkCrosstoolsR19.java | 78 ++++++++ .../ndkcrosstools/r19/ApiLevelR19.java | 61 +++++++ .../ndkcrosstools/r19/ArmCrosstools.java | 172 ++++++++++++++++++ .../r19/NdkMajorRevisionR19.java | 42 +++++ .../ndkcrosstools/r19/X86Crosstools.java | 118 ++++++++++++ .../android/AndroidNdkRepositoryTest.java | 8 +- .../android/android_ndk_integration_test.sh | 20 +- 8 files changed, 489 insertions(+), 12 deletions(-) create mode 100644 src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/AndroidNdkCrosstoolsR19.java create mode 100644 src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ApiLevelR19.java create mode 100644 src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ArmCrosstools.java create mode 100644 src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/NdkMajorRevisionR19.java create mode 100644 src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/X86Crosstools.java diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/AndroidNdkCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/AndroidNdkCrosstools.java index d595dfe5b340d2..ab4bd6e30dd20a 100644 --- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/AndroidNdkCrosstools.java +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/AndroidNdkCrosstools.java @@ -23,6 +23,7 @@ import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r15.NdkMajorRevisionR15; import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r17.NdkMajorRevisionR17; import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r18.NdkMajorRevisionR18; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19.NdkMajorRevisionR19; import com.google.devtools.build.lib.util.OS; import java.util.Map; @@ -50,6 +51,7 @@ private AndroidNdkCrosstools() {} .put(16, new NdkMajorRevisionR15("5.0.300080")) // no changes relevant to Bazel .put(17, new NdkMajorRevisionR17("6.0.2")) .put(18, new NdkMajorRevisionR18("7.0.2")) + .put(19, new NdkMajorRevisionR19("8.0.1")) .build(); public static final Map.Entry LATEST_KNOWN_REVISION = diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/AndroidNdkCrosstoolsR19.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/AndroidNdkCrosstoolsR19.java new file mode 100644 index 00000000000000..5fc2c6945b1d83 --- /dev/null +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/AndroidNdkCrosstoolsR19.java @@ -0,0 +1,78 @@ +// Copyright 2018 The Bazel Authors. All rights reserved. +// +// 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.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19; + +import com.google.common.collect.ImmutableList; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.NdkPaths; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.StlImpl; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CrosstoolRelease; +import java.util.ArrayList; +import java.util.List; + +/** Generates a CrosstoolRelease proto for the Android NDK. */ +final class AndroidNdkCrosstoolsR19 { + + /** + * Creates a CrosstoolRelease proto for the Android NDK, given the API level to use and the + * release revision. The crosstools are generated through code rather than checked in as a flat + * file to reduce the amount of templating needed (for parameters like the release name and + * certain paths), to reduce duplication, and to make it easier to support future versions of the + * NDK. TODO(bazel-team): Eventually we should move this into Skylark so the crosstools can be + * updated independently of Bazel itself. + * + * @return A CrosstoolRelease for the Android NDK. + */ + static CrosstoolRelease create( + NdkPaths ndkPaths, StlImpl stlImpl, String hostPlatform, String clangVersion) { + return CrosstoolRelease.newBuilder() + .setMajorVersion("android") + .setMinorVersion("") + .setDefaultTargetCpu("armeabi") + .addAllToolchain(createToolchains(ndkPaths, stlImpl, hostPlatform, clangVersion)) + .build(); + } + + private static ImmutableList createToolchains( + NdkPaths ndkPaths, StlImpl stlImpl, String hostPlatform, String clangVersion) { + + List toolchainBuilders = new ArrayList<>(); + toolchainBuilders.addAll(new ArmCrosstools(ndkPaths, stlImpl, clangVersion).createCrosstools()); + toolchainBuilders.addAll(new X86Crosstools(ndkPaths, stlImpl, clangVersion).createCrosstools()); + + ImmutableList.Builder toolchains = new ImmutableList.Builder<>(); + + // Set attributes common to all toolchains. + for (CToolchain.Builder toolchainBuilder : toolchainBuilders) { + toolchainBuilder + .setHostSystemName(hostPlatform) + .setTargetLibc("local") + .setAbiVersion(toolchainBuilder.getTargetCpu()) + .setAbiLibcVersion("local"); + + // builtin_sysroot is set individually on each toolchain. + // platforms/arch sysroot + toolchainBuilder.addCxxBuiltinIncludeDirectory("%sysroot%/usr/include"); + toolchainBuilder.addCxxBuiltinIncludeDirectory( + ndkPaths.createBuiltinSysroot() + "/usr/include"); + toolchainBuilder.addUnfilteredCxxFlag( + "-isystem%ndk%/usr/include".replace("%ndk%", ndkPaths.createBuiltinSysroot())); + + toolchains.add(toolchainBuilder.build()); + } + + return toolchains.build(); + } +} diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ApiLevelR19.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ApiLevelR19.java new file mode 100644 index 00000000000000..cdcee9caba93a1 --- /dev/null +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ApiLevelR19.java @@ -0,0 +1,61 @@ +// Copyright 2018 The Bazel Authors. All rights reserved. +// +// 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.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19; + +import com.google.common.collect.ImmutableListMultimap; +import com.google.common.collect.ImmutableMap; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.ApiLevel; +import com.google.devtools.build.lib.events.EventHandler; + +/** Class which encodes information from the Android NDK makefiles about API levels. */ +final class ApiLevelR19 extends ApiLevel { + /** This is the contents of {@code platforms/android-*} */ + private static final ImmutableListMultimap API_LEVEL_TO_ARCHITECTURES = + ImmutableListMultimap.builder() + .putAll("16", "arm", "x86") + .putAll("17", "arm", "x86") + .putAll("18", "arm", "x86") + .putAll("19", "arm", "x86") + .putAll("21", "arm", "x86", "arm64", "x86_64") + .putAll("22", "arm", "x86", "arm64", "x86_64") + .putAll("23", "arm", "x86", "arm64", "x86_64") + .putAll("24", "arm", "x86", "arm64", "x86_64") + .putAll("26", "arm", "x86", "arm64", "x86_64") + .putAll("27", "arm", "x86", "arm64", "x86_64") + .putAll("28", "arm", "x86", "arm64", "x86_64") + .build(); + + /** This map fill in the gaps of {@code API_LEVEL_TO_ARCHITECTURES}. */ + private static final ImmutableMap API_EQUIVALENCIES = + ImmutableMap.builder() + .put("16", "16") + .put("17", "16") + .put("18", "18") + .put("19", "19") + .put("20", "19") + .put("21", "21") + .put("22", "22") + .put("23", "23") + .put("24", "24") + .put("25", "24") + .put("26", "26") + .put("27", "27") + .put("28", "28") + .build(); + + ApiLevelR19(EventHandler eventHandler, String repositoryName, String apiLevel) { + super(API_LEVEL_TO_ARCHITECTURES, API_EQUIVALENCIES, eventHandler, repositoryName, apiLevel); + } +} diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ArmCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ArmCrosstools.java new file mode 100644 index 00000000000000..f88ee6672219fb --- /dev/null +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/ArmCrosstools.java @@ -0,0 +1,172 @@ +// Copyright 2018 The Bazel Authors. All rights reserved. +// +// 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.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19; + +import com.google.common.collect.ImmutableList; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.NdkPaths; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.StlImpl; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CompilationMode; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CompilationModeFlags; + +/** + * Crosstool definitions for ARM. These values are based on the setup.mk files in the Android NDK + * toolchain directories. + */ +final class ArmCrosstools { + private final NdkPaths ndkPaths; + private final StlImpl stlImpl; + private final String clangVersion; + + ArmCrosstools(NdkPaths ndkPaths, StlImpl stlImpl, String clangVersion) { + this.ndkPaths = ndkPaths; + this.stlImpl = stlImpl; + this.clangVersion = clangVersion; + } + + ImmutableList createCrosstools() { + CToolchain.Builder aarch64Toolchain = createAarch64ClangToolchain(); + CToolchain.Builder armeabiToolchain = createArmeabiClangToolchain(); + + stlImpl.addStlImpl(aarch64Toolchain, "4.9"); + stlImpl.addStlImpl(armeabiToolchain, "4.9"); + + return ImmutableList.builder() + .add(aarch64Toolchain) + .add(armeabiToolchain) + .build(); + } + + private CToolchain.Builder createAarch64ClangToolchain() { + String toolchainName = "aarch64-linux-android-4.9"; + String targetPlatform = "aarch64-linux-android"; + String gccToolchain = ndkPaths.createGccToolchainPath(toolchainName); + String llvmTriple = "aarch64-none-linux-android"; + + return CToolchain.newBuilder() + .setToolchainIdentifier("aarch64-linux-android-clang" + clangVersion) + .setTargetSystemName(targetPlatform) + .setTargetCpu("arm64-v8a") + .setCompiler("clang" + clangVersion) + .addAllToolPath(ndkPaths.createClangToolpaths(toolchainName, targetPlatform, null)) + .addCxxBuiltinIncludeDirectory( + ndkPaths.createClangToolchainBuiltinIncludeDirectory(clangVersion)) + .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm64")) + + // Compiler flags + .addCompilerFlag("-gcc-toolchain") + .addCompilerFlag(gccToolchain) + .addCompilerFlag("-target") + .addCompilerFlag(llvmTriple) + .addCompilerFlag("-ffunction-sections") + .addCompilerFlag("-funwind-tables") + .addCompilerFlag("-fstack-protector-strong") + .addCompilerFlag("-fpic") + .addCompilerFlag("-Wno-invalid-command-line-argument") + .addCompilerFlag("-Wno-unused-command-line-argument") + .addCompilerFlag("-no-canonical-prefixes") + .addCompilerFlag( + "-isystem%ndk%/usr/include/%triple%" + .replace("%ndk%", ndkPaths.createBuiltinSysroot()) + .replace("%triple%", targetPlatform)) + .addCompilerFlag("-D__ANDROID_API__=" + ndkPaths.getCorrectedApiLevel("arm")) + + // Linker flags + .addLinkerFlag("-gcc-toolchain") + .addLinkerFlag(gccToolchain) + .addLinkerFlag("-target") + .addLinkerFlag(llvmTriple) + .addLinkerFlag("-no-canonical-prefixes") + + // Additional release flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.OPT) + .addCompilerFlag("-O2") + .addCompilerFlag("-g") + .addCompilerFlag("-DNDEBUG")) + + // Additional debug flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.DBG) + .addCompilerFlag("-O0") + .addCompilerFlag("-g") + .addCompilerFlag("-UNDEBUG")); + } + + private CToolchain.Builder createArmeabiClangToolchain() { + String toolchainName = "arm-linux-androideabi-4.9"; + String targetPlatform = "arm-linux-androideabi"; + String gccToolchain = ndkPaths.createGccToolchainPath("arm-linux-androideabi-4.9"); + + return CToolchain.newBuilder() + .setToolchainIdentifier("arm-linux-androideabi-clang" + clangVersion + "-v7a") + .setTargetCpu("armeabi-v7a") + .setTargetSystemName("arm-linux-androideabi") + .setCompiler("clang" + clangVersion) + .addAllToolPath(ndkPaths.createClangToolpaths(toolchainName, targetPlatform, null)) + .addCxxBuiltinIncludeDirectory( + ndkPaths.createClangToolchainBuiltinIncludeDirectory(clangVersion)) + .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm")) + .addCompilerFlag("-D__ANDROID_API__=" + ndkPaths.getCorrectedApiLevel("arm")) + .addCompilerFlag( + "-isystem%ndk%/usr/include/%triple%" + .replace("%ndk%", ndkPaths.createBuiltinSysroot()) + .replace("%triple%", targetPlatform)) + + // Compiler flags + .addCompilerFlag("-target") + .addCompilerFlag("armv7-none-linux-androideabi") // LLVM_TRIPLE + .addCompilerFlag("-march=armv7-a") + .addCompilerFlag("-mfloat-abi=softfp") + .addCompilerFlag("-mfpu=vfpv3-d16") + .addCompilerFlag("-gcc-toolchain") + .addCompilerFlag(gccToolchain) + .addCompilerFlag("-fpic") + .addCompilerFlag("-ffunction-sections") + .addCompilerFlag("-funwind-tables") + .addCompilerFlag("-fstack-protector-strong") + .addCompilerFlag("-Wno-invalid-command-line-argument") + .addCompilerFlag("-Wno-unused-command-line-argument") + .addCompilerFlag("-no-canonical-prefixes") + + // Linker flags + .addLinkerFlag("-target") + .addLinkerFlag("armv7-none-linux-androideabi") // LLVM_TRIPLE + .addLinkerFlag("-Wl,--fix-cortex-a8") + .addLinkerFlag("-gcc-toolchain") + .addLinkerFlag(gccToolchain) + .addLinkerFlag("-no-canonical-prefixes") + + // Additional release flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.OPT) + .addCompilerFlag("-mthumb") + .addCompilerFlag("-Os") + .addCompilerFlag("-g") + .addCompilerFlag("-DNDEBUG")) + + // Additional debug flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.DBG) + .addCompilerFlag("-g") + .addCompilerFlag("-fno-strict-aliasing") + .addCompilerFlag("-O0") + .addCompilerFlag("-UNDEBUG")); + } +} diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/NdkMajorRevisionR19.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/NdkMajorRevisionR19.java new file mode 100644 index 00000000000000..067475d8391d7a --- /dev/null +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/NdkMajorRevisionR19.java @@ -0,0 +1,42 @@ +// Copyright 2018 The Bazel Authors. All rights reserved. +// +// 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.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19; + +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.ApiLevel; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.NdkMajorRevision; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.NdkPaths; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.StlImpl; +import com.google.devtools.build.lib.events.EventHandler; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CrosstoolRelease; + +/** Logic specific to Android NDK R17. */ +public class NdkMajorRevisionR19 implements NdkMajorRevision { + private final String clangVersion; + + public NdkMajorRevisionR19(String clangVersion) { + this.clangVersion = clangVersion; + } + + @Override + public CrosstoolRelease crosstoolRelease( + NdkPaths ndkPaths, StlImpl stlImpl, String hostPlatform) { + return AndroidNdkCrosstoolsR19.create(ndkPaths, stlImpl, hostPlatform, clangVersion); + } + + @Override + public ApiLevel apiLevel(EventHandler eventHandler, String name, String apiLevel) { + return new ApiLevelR19(eventHandler, name, apiLevel); + } +} diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/X86Crosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/X86Crosstools.java new file mode 100644 index 00000000000000..a3c24fe2276682 --- /dev/null +++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r19/X86Crosstools.java @@ -0,0 +1,118 @@ +// Copyright 2018 The Bazel Authors. All rights reserved. +// +// 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.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r19; + +import com.google.common.collect.ImmutableList; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.NdkPaths; +import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.StlImpl; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CompilationMode; +import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CompilationModeFlags; + +/** + * Crosstool definitions for x86. These values are based on the setup.mk files in the Android NDK + * toolchain directories. + */ +final class X86Crosstools { + private final NdkPaths ndkPaths; + private final StlImpl stlImpl; + private final String clangVersion; + + X86Crosstools(NdkPaths ndkPaths, StlImpl stlImpl, String clangVersion) { + this.ndkPaths = ndkPaths; + this.stlImpl = stlImpl; + this.clangVersion = clangVersion; + } + + ImmutableList createCrosstools() { + /** x86 */ + // clang + CToolchain.Builder x86Clang = + createBaseX86ClangToolchain("x86", "i686", "i686-linux-android") + // Workaround for https://code.google.com/p/android/issues/detail?id=220159. + .addCompilerFlag("-mstackrealign") + .setToolchainIdentifier("x86-clang" + clangVersion) + .setTargetCpu("x86") + .addAllToolPath(ndkPaths.createClangToolpaths("x86-4.9", "i686-linux-android", null)) + .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86")); + + stlImpl.addStlImpl(x86Clang, null); + + /** x86_64 */ + CToolchain.Builder x8664Clang = + createBaseX86ClangToolchain("x86_64", "x86_64", "x86_64-linux-android") + .setToolchainIdentifier("x86_64-clang" + clangVersion) + .setTargetCpu("x86_64") + .addAllToolPath( + ndkPaths.createClangToolpaths("x86_64-4.9", "x86_64-linux-android", null)) + .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64")); + + stlImpl.addStlImpl(x8664Clang, null); + + return ImmutableList.of(x86Clang, x8664Clang); + } + + private CToolchain.Builder createBaseX86ClangToolchain( + String x86Arch, String llvmArch, String triple) { + String gccToolchain = ndkPaths.createGccToolchainPath(x86Arch + "-4.9"); + String llvmTriple = llvmArch + "-none-linux-android"; + + return CToolchain.newBuilder() + .setCompiler("clang" + clangVersion) + .addCxxBuiltinIncludeDirectory( + ndkPaths.createClangToolchainBuiltinIncludeDirectory(clangVersion)) + + // Compiler flags + .addCompilerFlag("-gcc-toolchain") + .addCompilerFlag(gccToolchain) + .addCompilerFlag("-target") + .addCompilerFlag(llvmTriple) + .addCompilerFlag("-ffunction-sections") + .addCompilerFlag("-funwind-tables") + .addCompilerFlag("-fstack-protector-strong") + .addCompilerFlag("-fPIC") + .addCompilerFlag("-Wno-invalid-command-line-argument") + .addCompilerFlag("-Wno-unused-command-line-argument") + .addCompilerFlag("-no-canonical-prefixes") + .addCompilerFlag( + "-isystem%ndk%/usr/include/%triple%" + .replace("%ndk%", ndkPaths.createBuiltinSysroot()) + .replace("%triple%", triple)) + .addCompilerFlag("-D__ANDROID_API__=" + ndkPaths.getCorrectedApiLevel(x86Arch)) + + // Linker flags + .addLinkerFlag("-gcc-toolchain") + .addLinkerFlag(gccToolchain) + .addLinkerFlag("-target") + .addLinkerFlag(llvmTriple) + .addLinkerFlag("-no-canonical-prefixes") + + // Additional release flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.OPT) + .addCompilerFlag("-O2") + .addCompilerFlag("-g") + .addCompilerFlag("-DNDEBUG")) + + // Additional debug flags + .addCompilationModeFlags( + CompilationModeFlags.newBuilder() + .setMode(CompilationMode.DBG) + .addCompilerFlag("-O0") + .addCompilerFlag("-g")) + .setTargetSystemName("x86-linux-android"); + } +} diff --git a/src/test/java/com/google/devtools/build/lib/bazel/rules/android/AndroidNdkRepositoryTest.java b/src/test/java/com/google/devtools/build/lib/bazel/rules/android/AndroidNdkRepositoryTest.java index c75bad7eb217d4..5260e67ec454c1 100644 --- a/src/test/java/com/google/devtools/build/lib/bazel/rules/android/AndroidNdkRepositoryTest.java +++ b/src/test/java/com/google/devtools/build/lib/bazel/rules/android/AndroidNdkRepositoryTest.java @@ -115,7 +115,7 @@ public void testInvalidNdkReleaseTxt() throws Exception { eventCollector, "The revision of the Android NDK referenced by android_ndk_repository rule 'androidndk' " + "could not be determined (the revision string found is 'not a valid release string')." - + " Bazel will attempt to treat the NDK as if it was r18."); + + " Bazel will attempt to treat the NDK as if it was r19."); } @Test @@ -142,7 +142,7 @@ public void testInvalidNdkSourceProperties() throws Exception { eventCollector, "The revision of the Android NDK referenced by android_ndk_repository rule 'androidndk' " + "could not be determined (the revision string found is 'invalid package revision'). " - + "Bazel will attempt to treat the NDK as if it was r18."); + + "Bazel will attempt to treat the NDK as if it was r19."); } @Test @@ -166,8 +166,8 @@ public void testUnsupportedNdkVersion() throws Exception { eventCollector, "The major revision of the Android NDK referenced by android_ndk_repository rule " + "'androidndk' is 19. The major revisions supported by Bazel are " - + "[10, 11, 12, 13, 14, 15, 16, 17, 18]. Bazel will attempt to treat the NDK as if it " - + "was r18."); + + "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]. Bazel will attempt to treat the NDK as if " + + "it was r19."); } @Test diff --git a/src/test/shell/bazel/android/android_ndk_integration_test.sh b/src/test/shell/bazel/android/android_ndk_integration_test.sh index c8e85e7ee304a4..8c82626b5f701f 100755 --- a/src/test/shell/bazel/android/android_ndk_integration_test.sh +++ b/src/test/shell/bazel/android/android_ndk_integration_test.sh @@ -175,7 +175,7 @@ EOF function check_num_sos() { num_sos=$(unzip -Z1 bazel-bin/java/bazel/bin.apk '*.so' | wc -l | sed -e 's/[[:space:]]//g') - assert_equals "5" "$num_sos" + assert_equals "4" "$num_sos" } function check_soname() { @@ -202,7 +202,7 @@ function test_android_binary() { setup_android_ndk_support create_android_binary - cpus="armeabi,armeabi-v7a,arm64-v8a,x86,x86_64" + cpus="armeabi-v7a,arm64-v8a,x86,x86_64" bazel build -s //java/bazel:bin --fat_apk_cpu="$cpus" || fail "build failed" check_num_sos @@ -215,11 +215,11 @@ function test_android_binary_clang() { setup_android_ndk_support create_android_binary - cpus="armeabi,armeabi-v7a,arm64-v8a,x86,x86_64" + cpus="armeabi-v7a,arm64-v8a,x86,x86_64" bazel build -s //java/bazel:bin \ --fat_apk_cpu="$cpus" \ - --android_compiler=clang5.0.300080 \ + --android_compiler=clang8.0.1 \ || fail "build failed" check_num_sos check_soname @@ -234,6 +234,7 @@ cc_binary( name = "foo", srcs = ["foo.cc"], copts = ["-mfpu=neon"], + linkopts = ["-ldl"], ) EOF cat > foo.cc < foo.cc < BUILD < BUILD <