Adds support for NDK12 to Bazel. Also updates ndk crosstools test to include ndk12. The most significant departures from NDK11 are the removal of non-thumb ARM STLs, the removal of hard-fp arm and a change to the paths for gcc-4.9 toolchain.

RELNOTES: Adds support for NDK12 to `android_ndk_repository` rule in Bazel.

--
MOS_MIGRATED_REVID=128865535

7 files changed, 916 insertions, 4 deletions

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 1962da1b87..6ebaa69fb7 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
@@ -16,6 +16,7 @@ package com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools;
 
 import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r10e.AndroidNdkCrosstoolsR10e;
 import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r11.AndroidNdkCrosstoolsR11;
+import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r12.AndroidNdkCrosstoolsR12;
 import com.google.devtools.build.lib.util.OS;
 import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CrosstoolRelease;
 
@@ -28,7 +29,8 @@ public class AndroidNdkCrosstools {
   // to be tracked here are the major revision numbers.
   private static final String NDK_REVISION_10 = "10";
   private static final String NDK_REVISION_11 = "11";
-  public static final String LATEST_KNOWN_REVISION = NDK_REVISION_11;
+  private static final String NDK_REVISION_12 = "12";
+  public static final String LATEST_KNOWN_REVISION = NDK_REVISION_12;
 
   /**
    * Exception thrown when there is an error creating the crosstools file.
@@ -57,8 +59,10 @@ public class AndroidNdkCrosstools {
     // enough to check the major revision of the release.
     if (NDK_REVISION_10.equals(majorRevision)) {
       return AndroidNdkCrosstoolsR10e.create(ndkPaths, stlImpl, hostPlatform);
-    } else { 
+    } else if (NDK_REVISION_11.equals(majorRevision)) {
       return AndroidNdkCrosstoolsR11.create(ndkPaths, stlImpl, hostPlatform);
+    } else {
+      return AndroidNdkCrosstoolsR12.create(ndkPaths, stlImpl, hostPlatform);
     }
   }
 
@@ -94,6 +98,7 @@ public class AndroidNdkCrosstools {
 
   public static boolean isKnownNDKRevision(NdkRelease ndkRelease) {
     return NDK_REVISION_10.equals(ndkRelease.majorRevision)
-        || NDK_REVISION_11.equals(ndkRelease.majorRevision);
+        || NDK_REVISION_11.equals(ndkRelease.majorRevision)
+        || NDK_REVISION_12.equals(ndkRelease.majorRevision);
   } 
 }
\ No newline at end of file
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ApiLevel.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ApiLevel.java
index fbc8559f4e..14ccb785a4 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ApiLevel.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ApiLevel.java
@@ -19,6 +19,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r10e.ApiLevelR10e;
 import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r11.ApiLevelR11;
+import com.google.devtools.build.lib.bazel.rules.android.ndkcrosstools.r12.ApiLevelR12;
 import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.events.EventHandler;
 
@@ -32,8 +33,10 @@ public abstract class ApiLevel {
       NdkRelease release, EventHandler eventHandler, String repositoryName, String apiLevel) {
     if ("10".equals(release.majorRevision)) {
       return new ApiLevelR10e(eventHandler, repositoryName, apiLevel);
-    } else {
+    } else if ("11".equals(release.majorRevision)) {
       return new ApiLevelR11(eventHandler, repositoryName, apiLevel);
+    } else {
+      return new ApiLevelR12(eventHandler, repositoryName, apiLevel);
     }
   }
   
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/AndroidNdkCrosstoolsR12.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/AndroidNdkCrosstoolsR12.java
new file mode 100644
index 0000000000..eee1a3e534
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/AndroidNdkCrosstoolsR12.java
@@ -0,0 +1,113 @@
+// Copyright 2016 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.r12;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+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 com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.DefaultCpuToolchain;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+
+/** Generates a CrosstoolRelease proto for the Android NDK. */
+public class AndroidNdkCrosstoolsR12 {
+
+  private AndroidNdkCrosstoolsR12() {}
+
+  /**
+   * 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.
+   */
+  public static CrosstoolRelease create(NdkPaths ndkPaths, StlImpl stlImpl, String hostPlatform) {
+
+    CrosstoolRelease crosstoolRelease =
+        CrosstoolRelease.newBuilder()
+            .setMajorVersion("android")
+            .setMinorVersion("")
+            .setDefaultTargetCpu("armeabi")
+            .addAllDefaultToolchain(getDefaultCpuToolchains(stlImpl))
+            .addAllToolchain(createToolchains(ndkPaths, stlImpl, hostPlatform))
+            .build();
+
+    return crosstoolRelease;
+  }
+
+  private static ImmutableList<CToolchain> createToolchains(
+      NdkPaths ndkPaths, StlImpl stlImpl, String hostPlatform) {
+
+    List<CToolchain.Builder> toolchainBuilders = new ArrayList<>();
+    toolchainBuilders.addAll(new ArmCrosstools(ndkPaths, stlImpl).createCrosstools());
+    toolchainBuilders.addAll(new MipsCrosstools(ndkPaths, stlImpl).createCrosstools());
+    toolchainBuilders.addAll(new X86Crosstools(ndkPaths, stlImpl).createCrosstools());
+
+    ImmutableList.Builder<CToolchain> 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.
+      toolchainBuilder.addCxxBuiltinIncludeDirectory("%sysroot%/usr/include");
+
+      toolchains.add(toolchainBuilder.build());
+    }
+
+    return toolchains.build();
+  }
+
+  private static ImmutableList<DefaultCpuToolchain> getDefaultCpuToolchains(StlImpl stlImpl) {
+    // TODO(bazel-team): It would be better to auto-generate this somehow.
+
+    ImmutableMap<String, String> defaultCpus =
+        ImmutableMap.<String, String>builder()
+            // arm
+            .put("armeabi", "arm-linux-androideabi-4.9")
+            .put("armeabi-v7a", "arm-linux-androideabi-4.9-v7a")
+            .put("arm64-v8a", "aarch64-linux-android-4.9")
+
+            // mips
+            .put("mips", "mipsel-linux-android-4.9")
+            .put("mips64", "mips64el-linux-android-4.9")
+
+            // x86
+            .put("x86", "x86-4.9")
+            .put("x86_64", "x86_64-4.9")
+            .build();
+
+    ImmutableList.Builder<DefaultCpuToolchain> defaultCpuToolchains = ImmutableList.builder();
+    for (Entry<String, String> defaultCpu : defaultCpus.entrySet()) {
+      defaultCpuToolchains.add(
+          DefaultCpuToolchain.newBuilder()
+              .setCpu(defaultCpu.getKey())
+              .setToolchainIdentifier(defaultCpu.getValue() + "-" + stlImpl.getName())
+              .build());
+    }
+    return defaultCpuToolchains.build();
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/ApiLevelR12.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/ApiLevelR12.java
new file mode 100644
index 0000000000..b5fc0a6b43
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/ApiLevelR12.java
@@ -0,0 +1,103 @@
+// Copyright 2016 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.r12;
+
+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. */
+public class ApiLevelR12 extends ApiLevel {
+
+  private static final ImmutableListMultimap<String, String> API_LEVEL_TO_ARCHITECTURES =
+      ImmutableListMultimap.<String, String>builder()
+          .putAll("3", "arm")
+          .putAll("4", "arm")
+          .putAll("5", "arm")
+          .putAll("8", "arm")
+          .putAll("9", "arm", "mips", "x86")
+          .putAll("12", "arm", "mips", "x86")
+          .putAll("13", "arm", "mips", "x86")
+          .putAll("14", "arm", "mips", "x86")
+          .putAll("15", "arm", "mips", "x86")
+          .putAll("16", "arm", "mips", "x86")
+          .putAll("17", "arm", "mips", "x86")
+          .putAll("18", "arm", "mips", "x86")
+          .putAll("19", "arm", "mips", "x86")
+          .putAll("21", "arm", "mips", "x86", "arm64", "mips64", "x86_64")
+          .putAll("23", "arm", "mips", "x86", "arm64", "mips64", "x86_64")
+          .putAll("24", "arm", "mips", "x86", "arm64", "mips64", "x86_64")
+          .build();
+
+  /**
+   * Per the "special cases" listed in build/core/add-application.mk:
+   *
+   * <pre>
+   *   SPECIAL CASES:
+   *   1) android-6 and android-7 are the same thing as android-5
+   *   2) android-10 and android-11 are the same thing as android-9
+   *   3) android-20 is the same thing as android-19
+   *   4) android-21 and up are the same thing as android-21
+   *   ADDITIONAL CASES for remote server where total number of files is limited
+   *   5) android-13 is the same thing as android-12
+   *   6) android-15 is the same thing as android-14
+   *   7) android-17 is the same thing as android-16
+   * </pre>
+   */
+  private static final ImmutableMap<String, String> API_EQUIVALENCIES =
+      ImmutableMap.<String, String>builder()
+          .put("3", "3")
+          .put("4", "4")
+
+          // Case 1
+          .put("5", "5")
+          .put("6", "5")
+          .put("7", "5")
+          .put("8", "8")
+
+          // Case 2
+          .put("9", "9")
+          .put("10", "9")
+          .put("11", "9")
+
+          // Case 5
+          .put("12", "12")
+          .put("13", "12")
+
+          // Case 6
+          .put("14", "14")
+          .put("15", "14")
+
+          // Case 7
+          .put("16", "16")
+          .put("17", "16")
+          .put("18", "18")
+
+          // Case 3
+          .put("19", "19")
+          .put("20", "19")
+
+          // Case 4
+          .put("21", "21")
+          .put("22", "21")
+          .put("23", "23")
+          .put("24", "24")
+          .build();
+
+  public ApiLevelR12(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/r12/ArmCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/ArmCrosstools.java
new file mode 100644
index 0000000000..011bc50052
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/ArmCrosstools.java
@@ -0,0 +1,289 @@
+// Copyright 2016 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.r12;
+
+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;
+import java.util.List;
+
+/**
+ * Crosstool definitions for ARM. These values are based on the setup.mk files in the Android NDK
+ * toolchain directories.
+ */
+class ArmCrosstools {
+
+  private final NdkPaths ndkPaths;
+  private final StlImpl stlImpl;
+
+  ArmCrosstools(NdkPaths ndkPaths, StlImpl stlImpl) {
+    this.ndkPaths = ndkPaths;
+    this.stlImpl = stlImpl;
+  }
+
+  ImmutableList<CToolchain.Builder> createCrosstools() {
+    ImmutableList.Builder<CToolchain.Builder> toolchains = ImmutableList.builder();
+
+    toolchains.add(createAarch64Toolchain());
+    toolchains.add(createAarch64ClangToolchain());
+
+    toolchains.addAll(createArmeabiToolchains());
+    toolchains.addAll(createArmeabiClangToolchain());
+
+    return toolchains.build();
+  }
+
+  private CToolchain.Builder createAarch64Toolchain() {
+    String toolchainName = "aarch64-linux-android-4.9";
+    String targetPlatform = "aarch64-linux-android";
+
+    CToolchain.Builder toolchain =
+        CToolchain.newBuilder()
+            .setToolchainIdentifier("aarch64-linux-android-4.9")
+            .setTargetSystemName("aarch64-linux-android")
+            .setTargetCpu("arm64-v8a")
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(ndkPaths.createToolpaths(toolchainName, targetPlatform))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm64"))
+
+            // Compiler flags
+            .addCompilerFlag("-fpic")
+            .addCompilerFlag("-ffunction-sections")
+            .addCompilerFlag("-funwind-tables")
+            .addCompilerFlag("-fstack-protector-strong")
+            .addCompilerFlag("-no-canonical-prefixes")
+            .addCompilerFlag("-fno-canonical-system-headers")
+
+            // Linker flags
+            .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("-UNDEBUG"));
+
+    ndkPaths.addToolchainIncludePaths(toolchain, toolchainName, targetPlatform, "4.9.x");
+    stlImpl.addStlImpl(toolchain, "4.9");
+    return toolchain;
+  }
+
+  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";
+
+    CToolchain.Builder toolchain =
+        CToolchain.newBuilder()
+            .setToolchainIdentifier("aarch64-linux-android-clang3.8")
+            .setTargetSystemName("aarch64-linux-android")
+            .setTargetCpu("arm64-v8a")
+            .setCompiler("clang3.8")
+            .addAllToolPath(ndkPaths.createClangToolpaths(toolchainName, targetPlatform, null))
+            .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")
+
+            // 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("-UNDEBUG"));
+
+    ndkPaths.addToolchainIncludePaths(toolchain, toolchainName, targetPlatform, "4.9.x");
+    stlImpl.addStlImpl(toolchain, "4.9");
+    return toolchain;
+  }
+
+  private List<CToolchain.Builder> createArmeabiToolchains() {
+    ImmutableList<CToolchain.Builder> toolchains =
+        ImmutableList.of(
+            createBaseArmeabiToolchain()
+                .setToolchainIdentifier("arm-linux-androideabi-4.9")
+                .setTargetCpu("armeabi")
+                .addCompilerFlag("-march=armv5te")
+                .addCompilerFlag("-mtune=xscale")
+                .addCompilerFlag("-msoft-float"),
+            createBaseArmeabiToolchain()
+                .setToolchainIdentifier("arm-linux-androideabi-4.9-v7a")
+                .setTargetCpu("armeabi-v7a")
+                .addCompilerFlag("-march=armv7-a")
+                .addCompilerFlag("-mfpu=vfpv3-d16")
+                .addCompilerFlag("-mfloat-abi=softfp")
+                .addLinkerFlag("-march=armv7-a")
+                .addLinkerFlag("-Wl,--fix-cortex-a8"));
+    stlImpl.addStlImpl(toolchains, "4.9");
+    return toolchains;
+  }
+
+  /** Flags common to arm-linux-androideabi* */
+  private CToolchain.Builder createBaseArmeabiToolchain() {
+    String toolchainName = "arm-linux-androideabi-4.9";
+    String targetPlatform = "arm-linux-androideabi";
+
+    CToolchain.Builder toolchain =
+        CToolchain.newBuilder()
+            .setTargetSystemName(targetPlatform)
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(ndkPaths.createToolpaths(toolchainName, targetPlatform))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm"))
+
+            // Compiler flags
+            .addCompilerFlag("-fstack-protector-strong")
+            .addCompilerFlag("-fpic")
+            .addCompilerFlag("-ffunction-sections")
+            .addCompilerFlag("-funwind-tables")
+            .addCompilerFlag("-no-canonical-prefixes")
+            .addCompilerFlag("-fno-canonical-system-headers")
+
+            // Linker flags
+            .addLinkerFlag("-no-canonical-prefixes");
+
+    toolchain.addCompilationModeFlags(
+        CompilationModeFlags.newBuilder()
+            .setMode(CompilationMode.OPT)
+            .addCompilerFlag("-mthumb")
+            .addCompilerFlag("-Os")
+            .addCompilerFlag("-g")
+            .addCompilerFlag("-DNDEBUG"));
+
+    toolchain.addCompilationModeFlags(
+        CompilationModeFlags.newBuilder()
+            .setMode(CompilationMode.DBG)
+            .addCompilerFlag("-g")
+            .addCompilerFlag("-mthumb")
+            .addCompilerFlag("-O0")
+            .addCompilerFlag("-UNDEBUG"));
+
+    ndkPaths.addToolchainIncludePaths(toolchain, toolchainName, targetPlatform, "4.9.x");
+    return toolchain;
+  }
+
+  private List<CToolchain.Builder> createArmeabiClangToolchain() {
+    ImmutableList<CToolchain.Builder> toolchains =
+        ImmutableList.of(
+            createBaseArmeabiClangToolchain()
+                .setToolchainIdentifier("arm-linux-androideabi-clang3.8")
+                .setTargetCpu("armeabi")
+                .addCompilerFlag("-target")
+                .addCompilerFlag("armv5te-none-linux-androideabi") // LLVM_TRIPLE
+                .addCompilerFlag("-march=armv5te")
+                .addCompilerFlag("-mtune=xscale")
+                .addCompilerFlag("-msoft-float")
+                .addLinkerFlag("-target")
+                // LLVM_TRIPLE
+                .addLinkerFlag("armv5te-none-linux-androideabi"),
+            createBaseArmeabiClangToolchain()
+                .setToolchainIdentifier("arm-linux-androideabi-clang3.8-v7a")
+                .setTargetCpu("armeabi-v7a")
+                .addCompilerFlag("-target")
+                .addCompilerFlag("armv7-none-linux-androideabi") // LLVM_TRIPLE
+                .addCompilerFlag("-march=armv7-a")
+                .addCompilerFlag("-mfloat-abi=softfp")
+                .addCompilerFlag("-mfpu=vfpv3-d16")
+                .addLinkerFlag("-target")
+                .addLinkerFlag("armv7-none-linux-androideabi") // LLVM_TRIPLE
+                .addLinkerFlag("-Wl,--fix-cortex-a8"));
+    stlImpl.addStlImpl(toolchains, "4.9");
+    return toolchains;
+  }
+
+  private CToolchain.Builder createBaseArmeabiClangToolchain() {
+    String toolchainName = "arm-linux-androideabi-4.9";
+    String targetPlatform = "arm-linux-androideabi";
+    String gccToolchain = ndkPaths.createGccToolchainPath("arm-linux-androideabi-4.9");
+
+    CToolchain.Builder toolchain =
+        CToolchain.newBuilder()
+            .setTargetSystemName("arm-linux-androideabi")
+            .setCompiler("clang3.8")
+            .addAllToolPath(ndkPaths.createClangToolpaths(toolchainName, targetPlatform, null))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm"))
+
+            // Compiler flags
+            .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")
+            .addCompilerFlag("-fno-integrated-as")
+
+            // Linker flags
+            .addLinkerFlag("-gcc-toolchain")
+            .addLinkerFlag(gccToolchain)
+            .addLinkerFlag("-no-canonical-prefixes");
+
+    toolchain.addCompilationModeFlags(
+        CompilationModeFlags.newBuilder()
+            .setMode(CompilationMode.OPT)
+            .addCompilerFlag("-mthumb")
+            .addCompilerFlag("-Os")
+            .addCompilerFlag("-g")
+            .addCompilerFlag("-DNDEBUG"));
+    toolchain.addCompilationModeFlags(
+        CompilationModeFlags.newBuilder()
+            .setMode(CompilationMode.DBG)
+            .addCompilerFlag("-g")
+            .addCompilerFlag("-fno-strict-aliasing")
+            .addCompilerFlag("-O0")
+            .addCompilerFlag("-UNDEBUG"));
+    ndkPaths.addToolchainIncludePaths(toolchain, toolchainName, targetPlatform, "4.9.x");
+    return toolchain;
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/MipsCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/MipsCrosstools.java
new file mode 100644
index 0000000000..dcb98086b7
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/MipsCrosstools.java
@@ -0,0 +1,218 @@
+// Copyright 2016 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.r12;
+
+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.rules.cpp.CppConfiguration;
+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;
+import java.util.List;
+
+/**
+ * Crosstool definitions for MIPS. These values are based on the setup.mk files in the Android NDK
+ * toolchain directories.
+ */
+class MipsCrosstools {
+
+  private final NdkPaths ndkPaths;
+  private final StlImpl stlImpl;
+
+  MipsCrosstools(NdkPaths ndkPaths, StlImpl stlImpl) {
+    this.ndkPaths = ndkPaths;
+    this.stlImpl = stlImpl;
+  }
+
+  ImmutableList<CToolchain.Builder> createCrosstools() {
+
+    ImmutableList.Builder<CToolchain.Builder> toolchains = ImmutableList.builder();
+
+    toolchains.addAll(createMips64Toolchains());
+    toolchains.addAll(createMipsToolchains());
+
+    return toolchains.build();
+  }
+
+  private List<CToolchain.Builder> createMips64Toolchains() {
+
+    ImmutableList.Builder<CToolchain.Builder> toolchainsListBuilder = ImmutableList.builder();
+
+    toolchainsListBuilder.add(
+        createBaseMipsToolchain()
+            .setToolchainIdentifier("mips64el-linux-android-4.9")
+            .setTargetSystemName("mips64el-linux-android")
+            .setTargetCpu("mips64")
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(
+                ndkPaths.createToolpaths(
+                    "mips64el-linux-android-4.9",
+                    "mips64el-linux-android",
+                    // mips64 toolchain doesn't have the dwp tool.
+                    CppConfiguration.Tool.DWP))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64")));
+
+    toolchainsListBuilder.add(
+        createBaseMipsClangToolchain("mips64el")
+            .setToolchainIdentifier("mips64el-linux-android-clang3.8")
+            .setTargetSystemName("mips64el-linux-android")
+            .setTargetCpu("mips64")
+            .addAllToolPath(
+                ndkPaths.createClangToolpaths(
+                    "mips64el-linux-android-4.9",
+                    "mips64el-linux-android",
+                    null,
+                    CppConfiguration.Tool.DWP))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64")));
+
+    List<CToolchain.Builder> toolchains = toolchainsListBuilder.build();
+    ndkPaths.addToolchainIncludePaths(
+        toolchains, "mips64el-linux-android-4.9", "mips64el-linux-android", "4.9.x");
+    stlImpl.addStlImpl(toolchains, "4.9");
+    return toolchains;
+  }
+
+  private List<CToolchain.Builder> createMipsToolchains() {
+
+    ImmutableList.Builder<CToolchain.Builder> toolchainsListBuilder = ImmutableList.builder();
+
+    // The gcc-4.9 mips toolchain doesn't have the dwp tool.
+    toolchainsListBuilder.add(createMipsToolchain());
+
+    CToolchain.Builder mipsClang =
+        createBaseMipsClangToolchain("mipsel")
+            // Purposefully no hyphen between "clang" and clang version.
+            .setToolchainIdentifier("mipsel-linux-android-clang3.8")
+            .setTargetSystemName("mipsel-linux-android")
+            .setTargetCpu("mips")
+            .addAllToolPath(
+                ndkPaths.createClangToolpaths(
+                    "mipsel-linux-android-4.9",
+                    "mipsel-linux-android",
+                    null,
+                    CppConfiguration.Tool.DWP,
+                    CppConfiguration.Tool.GCOVTOOL))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips"));
+
+    ndkPaths.addToolchainIncludePaths(
+        mipsClang, "mipsel-linux-android-4.9", "mipsel-linux-android", "4.9.x");
+    stlImpl.addStlImpl(mipsClang, "4.9");
+    toolchainsListBuilder.add(mipsClang);
+
+    return toolchainsListBuilder.build();
+  }
+
+  private CToolchain.Builder createMipsToolchain() {
+
+    CToolchain.Builder toolchain =
+        createBaseMipsToolchain()
+            .setToolchainIdentifier("mipsel-linux-android-4.9")
+            .setTargetSystemName("mipsel-linux-android")
+            .setTargetCpu("mips")
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(
+                ndkPaths.createToolpaths(
+                    "mipsel-linux-android-4.9", "mipsel-linux-android", CppConfiguration.Tool.DWP))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips"));
+
+    ndkPaths.addToolchainIncludePaths(
+        toolchain, "mipsel-linux-android-4.9", "mipsel-linux-android", "4.9.x");
+    stlImpl.addStlImpl(toolchain, "4.9");
+    return toolchain;
+  }
+
+  private CToolchain.Builder createBaseMipsToolchain() {
+    return CToolchain.newBuilder()
+        // Compiler flags
+        .addCompilerFlag("-fpic")
+        .addCompilerFlag("-finline-functions")
+        .addCompilerFlag("-ffunction-sections")
+        .addCompilerFlag("-funwind-tables")
+        .addCompilerFlag("-fmessage-length=0")
+        .addCompilerFlag("-fno-inline-functions-called-once")
+        .addCompilerFlag("-fgcse-after-reload")
+        .addCompilerFlag("-frerun-cse-after-loop")
+        .addCompilerFlag("-frename-registers")
+        .addCompilerFlag("-no-canonical-prefixes")
+        .addCompilerFlag("-fno-canonical-system-headers")
+
+        // Linker flags
+        .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"));
+  }
+
+  private CToolchain.Builder createBaseMipsClangToolchain(String mipsArch) {
+
+    String gccToolchain =
+        ndkPaths.createGccToolchainPath(String.format("%s-linux-android-4.9", mipsArch));
+
+    String llvmTriple = mipsArch + "-none-linux-android";
+
+    return CToolchain.newBuilder()
+        .setCompiler("clang3.8")
+
+        // Compiler flags
+        .addCompilerFlag("-gcc-toolchain")
+        .addCompilerFlag(gccToolchain)
+        .addCompilerFlag("-target")
+        .addCompilerFlag(llvmTriple)
+        .addCompilerFlag("-fpic")
+        .addCompilerFlag("-fno-strict-aliasing")
+        .addCompilerFlag("-finline-functions")
+        .addCompilerFlag("-ffunction-sections")
+        .addCompilerFlag("-funwind-tables")
+        .addCompilerFlag("-fmessage-length=0")
+        .addCompilerFlag("-Wno-invalid-command-line-argument")
+        .addCompilerFlag("-Wno-unused-command-line-argument")
+        .addCompilerFlag("-no-canonical-prefixes")
+
+        // 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"));
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/X86Crosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/X86Crosstools.java
new file mode 100644
index 0000000000..d61745ae3b
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/r12/X86Crosstools.java
@@ -0,0 +1,181 @@
+// Copyright 2016 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.r12;
+
+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.
+ */
+class X86Crosstools {
+
+  private final NdkPaths ndkPaths;
+  private final StlImpl stlImpl;
+
+  X86Crosstools(NdkPaths ndkPaths, StlImpl stlImpl) {
+    this.ndkPaths = ndkPaths;
+    this.stlImpl = stlImpl;
+  }
+
+  ImmutableList<CToolchain.Builder> createCrosstools() {
+
+    ImmutableList.Builder<CToolchain.Builder> toolchains = ImmutableList.builder();
+
+    /** x86 */
+
+    // gcc 4.9
+    toolchains.add(createX86Toolchain());
+    // clang
+    CToolchain.Builder x86Clang =
+        createBaseX86ClangToolchain("x86", "i686")
+            .setToolchainIdentifier("x86-clang3.8")
+            .setTargetCpu("x86")
+            .addAllToolPath(ndkPaths.createClangToolpaths("x86-4.9", "i686-linux-android", null))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"));
+
+    ndkPaths.addToolchainIncludePaths(x86Clang, "x86-4.9", "i686-linux-android", "4.9.x");
+    stlImpl.addStlImpl(x86Clang, "4.9");
+    toolchains.add(x86Clang);
+
+    /** x86_64 */
+    CToolchain.Builder x8664 =
+        createBaseX86Toolchain()
+            .setToolchainIdentifier("x86_64-4.9")
+            .setTargetCpu("x86_64")
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(ndkPaths.createToolpaths("x86_64-4.9", "x86_64-linux-android"))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64"))
+            .addCompilerFlag("-fstack-protector-strong");
+
+    ndkPaths.addToolchainIncludePaths(x8664, "x86_64-4.9", "x86_64-linux-android", "4.9.x");
+    stlImpl.addStlImpl(x8664, "4.9");
+    toolchains.add(x8664);
+
+    CToolchain.Builder x8664Clang =
+        createBaseX86ClangToolchain("x86_64", "x86_64")
+            .setToolchainIdentifier("x86_64-clang3.8")
+            .setTargetCpu("x86_64")
+            .addAllToolPath(
+                ndkPaths.createClangToolpaths("x86_64-4.9", "x86_64-linux-android", null))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64"));
+
+    ndkPaths.addToolchainIncludePaths(x8664Clang, "x86_64-4.9", "x86_64-linux-android", "4.9.x");
+    stlImpl.addStlImpl(x8664Clang, "4.9");
+    toolchains.add(x8664Clang);
+
+    ImmutableList<CToolchain.Builder> toolchainBuilders = toolchains.build();
+
+    // x86_64 also sets "x86-linux-android"
+    for (CToolchain.Builder toolchainBuilder : toolchainBuilders) {
+      toolchainBuilder.setTargetSystemName("x86-linux-android");
+    }
+
+    return toolchainBuilders;
+  }
+
+  private CToolchain.Builder createX86Toolchain() {
+
+    CToolchain.Builder toolchain =
+        createBaseX86Toolchain()
+            .setToolchainIdentifier("x86-4.9")
+            .setTargetCpu("x86")
+            .setCompiler("gcc-4.9")
+            .addAllToolPath(ndkPaths.createToolpaths("x86-4.9", "i686-linux-android"))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
+            .addCompilerFlag("-fstack-protector-strong");
+
+    ndkPaths.addToolchainIncludePaths(toolchain, "x86-4.9", "i686-linux-android", "4.9.x");
+    stlImpl.addStlImpl(toolchain, "4.9");
+    return toolchain;
+  }
+
+  private CToolchain.Builder createBaseX86Toolchain() {
+    return CToolchain.newBuilder()
+        // Compiler flags
+        .addCompilerFlag("-ffunction-sections")
+        .addCompilerFlag("-funwind-tables")
+        .addCompilerFlag("-no-canonical-prefixes")
+        .addCompilerFlag("-fno-canonical-system-headers")
+
+        // Linker flags
+        .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"));
+  }
+
+  private CToolchain.Builder createBaseX86ClangToolchain(String x86Arch, String llvmArch) {
+
+    String gccToolchain = ndkPaths.createGccToolchainPath(x86Arch + "-4.9");
+
+    String llvmTriple = llvmArch + "-none-linux-android";
+
+    return CToolchain.newBuilder()
+        .setCompiler("clang3.8")
+
+        // 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")
+
+        // 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"));
+  }
+}