Link Android native code with libstdc++, statically.

- Refactor the ndk toolchain generation to properly set the dynamic and static
  runtime lib filegroups.
- Enable the runtime filegroups.
- Change the NativeDepsHelper to work as documented - mostly static means
  statically linking the runtime filegroups; but only for Android to remain
  backwards compatible with other users of NativeDepsHelper.
- This is safe as we don't use runtime filegroups internally for Android...
  yet.
- Clean up the NativeDepsHelper a bit.

Fixes #392.

Next steps are to make this configurable at the android_binary level. We
should also disable whole-archive in this case.

--
Change-Id: I95b0ce45d8b3adcf5424544c92ec30102b7fac6b
Reviewed-on: https://bazel-review.googlesource.com/1879
MOS_MIGRATED_REVID=102239337

7 files changed, 411 insertions, 258 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/android_ndk_cc_toolchain_template.txt b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/android_ndk_cc_toolchain_template.txt
index 6dbdd17bae..dabbc066c3 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/android_ndk_cc_toolchain_template.txt
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/android_ndk_cc_toolchain_template.txt
@@ -8,17 +8,17 @@ cc_toolchain(
     compiler_files = ":%toolchainName%-toolchain_files",
     cpu = "%cpu%",
     dwp_files = ":%toolchainName%-toolchain_files",
-    dynamic_runtime_libs = [":%toolchainName%-toolchain_files"],
+    dynamic_runtime_libs = [":dynamic-runtime-libs-%toolchainName%"],
     linker_files = ":%toolchainName%-toolchain_files",
     objcopy_files = ":%toolchainName%-toolchain_files",
-    static_runtime_libs = [":%toolchainName%-toolchain_files"],
+    static_runtime_libs = [":static-runtime-libs-%toolchainName%"],
     strip_files = ":%toolchainName%-toolchain_files",
     supports_param_files = 0,
 )
 
 filegroup(
     name = "%toolchainName%-toolchain_files",
-    srcs = glob(["toolchains/%toolchainDirectory%/**"]),
+    srcs = glob(["ndk/toolchains/%toolchainDirectory%/**"]),
     output_licenses = ["unencumbered"],
 )
 
@@ -30,3 +30,13 @@ filegroup(
         %toolchainFileGlobs%
     ]),
 )
+
+filegroup(
+    name = "static-runtime-libs-%toolchainName%",
+    srcs = glob(["ndk/sources/cxx-stl/gnu-libstdc++/4.9/libs/%cpu%/*.a"]),
+)
+
+filegroup(
+    name = "dynamic-runtime-libs-%toolchainName%",
+    srcs = glob(["ndk/sources/cxx-stl/gnu-libstdc++/4.9/libs/%cpu%/*.so"]),
+)
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 4ba18b8874..dc10575df2 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
@@ -139,18 +139,31 @@ public class AndroidNdkCrosstools {
     // Extract the gcc version from the compiler, which should look like "gcc-4.8" or "gcc-4.9".
     String gccVersion = baseToolchain.getCompiler().split("-")[1];
 
-    toolchains.add(CToolchain.newBuilder(baseToolchain)
-        .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-gnu-libstdcpp")
-        .addAllUnfilteredCxxFlag(createIncludeFlags(ndkPaths.createGnuLibstdcIncludePaths(
-            gccVersion, baseToolchain.getTargetCpu()))));
-
-    toolchains.add(CToolchain.newBuilder(baseToolchain)
-        .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-libcpp")
-        .addAllUnfilteredCxxFlag(createIncludeFlags(ndkPaths.createLibcxxIncludePaths())));
-
-    toolchains.add(CToolchain.newBuilder(baseToolchain)
-        .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-stlport")
-        .addAllUnfilteredCxxFlag(createIncludeFlags(ndkPaths.createStlportIncludePaths())));
+    toolchains.add(
+        CToolchain.newBuilder(baseToolchain)
+            .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-gnu-libstdcpp")
+            .addAllUnfilteredCxxFlag(
+                createIncludeFlags(
+                    ndkPaths.createGnuLibstdcIncludePaths(
+                        gccVersion, baseToolchain.getTargetCpu())))
+            .setStaticRuntimesFilegroup(
+                baseToolchain.getStaticRuntimesFilegroup() + "-gnu-libstdcpp")
+            .setDynamicRuntimesFilegroup(
+                baseToolchain.getDynamicRuntimesFilegroup() + "-gnu-libstdcpp"));
+
+    toolchains.add(
+        CToolchain.newBuilder(baseToolchain)
+            .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-libcpp")
+            .addAllUnfilteredCxxFlag(createIncludeFlags(ndkPaths.createLibcxxIncludePaths()))
+            .setStaticRuntimesFilegroup(baseToolchain.getStaticRuntimesFilegroup() + "-libcpp")
+            .setDynamicRuntimesFilegroup(baseToolchain.getDynamicRuntimesFilegroup() + "-libcpp"));
+
+    toolchains.add(
+        CToolchain.newBuilder(baseToolchain)
+            .setToolchainIdentifier(baseToolchain.getToolchainIdentifier() + "-stlport")
+            .addAllUnfilteredCxxFlag(createIncludeFlags(ndkPaths.createStlportIncludePaths()))
+            .setStaticRuntimesFilegroup(baseToolchain.getStaticRuntimesFilegroup() + "-stlport")
+            .setDynamicRuntimesFilegroup(baseToolchain.getDynamicRuntimesFilegroup() + "-stlport"));
 
     return toolchains.build();
   }
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ArmCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ArmCrosstools.java
index dd046558c6..d79c216a05 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ArmCrosstools.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/ArmCrosstools.java
@@ -90,11 +90,15 @@ class ArmCrosstools {
 
         .addAllToolPath(ndkPaths.createToolpaths(toolchainName, targetPlatform))
 
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            toolchainName, targetPlatform, "4.9"))
+        .addAllCxxBuiltinIncludeDirectory(
+            ndkPaths.createToolchainIncludePaths(toolchainName, targetPlatform, "4.9"))
 
         .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm64"))
 
+        .setSupportsEmbeddedRuntimes(true)
+        .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainName)
+        .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + toolchainName)
+
         // Compiler flags
         .addCompilerFlag("-fpic")
         .addCompilerFlag("-ffunction-sections")
@@ -106,23 +110,25 @@ class ArmCrosstools {
         .addLinkerFlag("-no-canonical-prefixes")
 
         // Additional release flags
-        .addCompilationModeFlags(CompilationModeFlags.newBuilder()
-            .setMode(CompilationMode.OPT)
-            .addCompilerFlag("-O2")
-            .addCompilerFlag("-g")
-            .addCompilerFlag("-DNDEBUG")
-            .addCompilerFlag("-fomit-frame-pointer")
-            .addCompilerFlag("-fstrict-aliasing")
-            .addCompilerFlag("-funswitch-loops")
-            .addCompilerFlag("-finline-limit=300"))
+        .addCompilationModeFlags(
+            CompilationModeFlags.newBuilder()
+                .setMode(CompilationMode.OPT)
+                .addCompilerFlag("-O2")
+                .addCompilerFlag("-g")
+                .addCompilerFlag("-DNDEBUG")
+                .addCompilerFlag("-fomit-frame-pointer")
+                .addCompilerFlag("-fstrict-aliasing")
+                .addCompilerFlag("-funswitch-loops")
+                .addCompilerFlag("-finline-limit=300"))
 
         // Additional debug flags
-        .addCompilationModeFlags(CompilationModeFlags.newBuilder()
-            .setMode(CompilationMode.DBG)
-            .addCompilerFlag("-O0")
-            .addCompilerFlag("-UNDEBUG")
-            .addCompilerFlag("-fno-omit-frame-pointer")
-            .addCompilerFlag("-fno-strict-aliasing"));
+        .addCompilationModeFlags(
+            CompilationModeFlags.newBuilder()
+                .setMode(CompilationMode.DBG)
+                .addCompilerFlag("-O0")
+                .addCompilerFlag("-UNDEBUG")
+                .addCompilerFlag("-fno-omit-frame-pointer")
+                .addCompilerFlag("-fno-strict-aliasing"));
   }
 
   private CToolchain.Builder createAarch64ClangToolchain(String clangVersion) {
@@ -140,11 +146,15 @@ class ArmCrosstools {
 
         .addAllToolPath(ndkPaths.createClangToolpaths(toolchainName, targetPlatform, clangVersion))
 
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            toolchainName, targetPlatform, "4.9"))
+        .addAllCxxBuiltinIncludeDirectory(
+            ndkPaths.createToolchainIncludePaths(toolchainName, targetPlatform, "4.9"))
 
         .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm64"))
 
+        .setSupportsEmbeddedRuntimes(true)
+        .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainName)
+        .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + toolchainName)
+
         // Compiler flags
         .addCompilerFlag("-gcc-toolchain")
         .addCompilerFlag(gccToolchain)
@@ -157,7 +167,7 @@ class ArmCrosstools {
         .addCompilerFlag("-Wno-invalid-command-line-argument")
         .addCompilerFlag("-Wno-unused-command-line-argument")
         .addCompilerFlag("-no-canonical-prefixes")
-  
+
         // Linker flags
         .addLinkerFlag("-gcc-toolchain")
         .addLinkerFlag(gccToolchain)
@@ -166,21 +176,23 @@ class ArmCrosstools {
         .addLinkerFlag("-no-canonical-prefixes")
 
         // Additional release flags
-        .addCompilationModeFlags(CompilationModeFlags.newBuilder()
-            .setMode(CompilationMode.OPT)
-            .addCompilerFlag("-O2")
-            .addCompilerFlag("-g")
-            .addCompilerFlag("-DNDEBUG")
-            .addCompilerFlag("-fomit-frame-pointer")
-            .addCompilerFlag("-fstrict-aliasing"))
+        .addCompilationModeFlags(
+            CompilationModeFlags.newBuilder()
+                .setMode(CompilationMode.OPT)
+                .addCompilerFlag("-O2")
+                .addCompilerFlag("-g")
+                .addCompilerFlag("-DNDEBUG")
+                .addCompilerFlag("-fomit-frame-pointer")
+                .addCompilerFlag("-fstrict-aliasing"))
 
         // Additional debug flags
-        .addCompilationModeFlags(CompilationModeFlags.newBuilder()
-            .setMode(CompilationMode.DBG)
-            .addCompilerFlag("-O0")
-            .addCompilerFlag("-UNDEBUG")
-            .addCompilerFlag("-fno-omit-frame-pointer")
-            .addCompilerFlag("-fno-strict-aliasing"));
+        .addCompilationModeFlags(
+            CompilationModeFlags.newBuilder()
+                .setMode(CompilationMode.DBG)
+                .addCompilerFlag("-O0")
+                .addCompilerFlag("-UNDEBUG")
+                .addCompilerFlag("-fno-omit-frame-pointer")
+                .addCompilerFlag("-fno-strict-aliasing"));
   }
 
   private void createArmeabiToolchain(ImmutableList.Builder<CToolchain.Builder> builder,
@@ -249,24 +261,29 @@ class ArmCrosstools {
         targetPlatform,
         gccVersion);
 
-    CToolchain.Builder builder = CToolchain.newBuilder()
-        .setTargetSystemName(targetPlatform)
-        .setCompiler("gcc-" + gccVersion)
+    CToolchain.Builder builder =
+        CToolchain.newBuilder()
+            .setTargetSystemName(targetPlatform)
+            .setCompiler("gcc-" + gccVersion)
 
-        .addAllToolPath(toolPaths)
-        .addAllCxxBuiltinIncludeDirectory(toolchainIncludes)
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm"))
+            .addAllToolPath(toolPaths)
+            .addAllCxxBuiltinIncludeDirectory(toolchainIncludes)
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm"))
 
-        .addCompilerFlag(stackProtectorFlag)
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainName)
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + toolchainName)
 
-        // Compiler flags
-        .addCompilerFlag("-fpic")
-        .addCompilerFlag("-ffunction-sections")
-        .addCompilerFlag("-funwind-tables")
-        .addCompilerFlag("-no-canonical-prefixes")
+            .addCompilerFlag(stackProtectorFlag)
 
-        // Linker flags
-        .addLinkerFlag("-no-canonical-prefixes");
+            // Compiler flags
+            .addCompilerFlag("-fpic")
+            .addCompilerFlag("-ffunction-sections")
+            .addCompilerFlag("-funwind-tables")
+            .addCompilerFlag("-no-canonical-prefixes")
+
+            // Linker flags
+            .addLinkerFlag("-no-canonical-prefixes");
 
     if (thumb) {
       builder.addCompilationModeFlags(CompilationModeFlags.newBuilder()
@@ -371,38 +388,44 @@ class ArmCrosstools {
     String targetPlatform = "arm-linux-androideabi";
     String gccToolchain = ndkPaths.createGccToolchainPath("arm-linux-androideabi-4.8");
 
-    CToolchain.Builder builder = CToolchain.newBuilder()
-        .setTargetSystemName("arm-linux-androideabi")
-        .setCompiler("gcc-4.8")
-
-        .addAllToolPath(ndkPaths.createClangToolpaths(
-            toolchainName,
-            targetPlatform,
-            clangVersion,
-            // gcc-4.8 arm doesn't have gcov-tool
-            CppConfiguration.Tool.GCOVTOOL))
-
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            toolchainName, targetPlatform, "4.8"))
-
-        .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");
+    CToolchain.Builder builder =
+        CToolchain.newBuilder()
+            .setTargetSystemName("arm-linux-androideabi")
+            .setCompiler("gcc-4.8")
+
+            .addAllToolPath(
+                ndkPaths.createClangToolpaths(
+                    toolchainName,
+                    targetPlatform,
+                    clangVersion,
+                    // gcc-4.8 arm doesn't have gcov-tool
+                    CppConfiguration.Tool.GCOVTOOL))
+
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths(toolchainName, targetPlatform, "4.8"))
+
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("arm"))
+
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainName)
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + toolchainName)
+
+            // 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");
 
     if (thumb) {
       builder.addCompilationModeFlags(CompilationModeFlags.newBuilder()
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/MipsCrosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/MipsCrosstools.java
index afe5d9abd4..8652789e05 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/MipsCrosstools.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/MipsCrosstools.java
@@ -40,95 +40,140 @@ class MipsCrosstools {
      * mips64
      */
 
-    builder.add(createMipsToolchain()
-        .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))
-
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            "mips64el-linux-android-4.9", "mips64el-linux-android", "4.9"))
-
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64")));
+    builder.add(
+        createMipsToolchain()
+            .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))
+
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths(
+                    "mips64el-linux-android-4.9", "mips64el-linux-android", "4.9"))
+
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64"))
+
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "mips64el-linux-android-4.9")
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + "mips64el-linux-android-4.9"));
 
     // The flags for mips64 clang 3.5 and 3.6 are the same, they differ only in the LLVM version
     // given in their tool paths.
     for (String clangVersion : new String[] { "3.5", "3.6" }) {
-      builder.add(createMipsClangToolchain("mips64", "4.9")
-          .setToolchainIdentifier("mips64el-linux-android-clang" + clangVersion)
-          .setTargetSystemName("mips64el-linux-android")
-          .setTargetCpu("mips64")
-          .setCompiler("gcc-4.9")
-
-          .addAllToolPath(ndkPaths.createClangToolpaths(
-              "mips64el-linux-android-4.9", "mips64el-linux-android", clangVersion,
-              CppConfiguration.Tool.DWP))
-
-          .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-              "mips64el-linux-android-4.9", "mips64el-linux-android", "4.9"))
-
-          .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64")));
+      String toolchainIdentifier = "mips64el-linux-android-clang" + clangVersion;
+      builder.add(
+          createMipsClangToolchain("mips64", "4.9")
+              .setToolchainIdentifier(toolchainIdentifier)
+              .setTargetSystemName("mips64el-linux-android")
+              .setTargetCpu("mips64")
+              .setCompiler("gcc-4.9")
+
+              .addAllToolPath(
+                  ndkPaths.createClangToolpaths(
+                      "mips64el-linux-android-4.9",
+                      "mips64el-linux-android",
+                      clangVersion,
+                      CppConfiguration.Tool.DWP))
+
+              .addAllCxxBuiltinIncludeDirectory(
+                  ndkPaths.createToolchainIncludePaths(
+                      "mips64el-linux-android-4.9", "mips64el-linux-android", "4.9"))
+
+              .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips64"))
+
+              .setSupportsEmbeddedRuntimes(true)
+              .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainIdentifier)
+              .setDynamicRuntimesFilegroup("static-runtime-libs-" + toolchainIdentifier));
     }
 
     /**
      * mips
      */
 
-    builder.add(createMipsToolchain()
-        .setToolchainIdentifier("mipsel-linux-android-4.8")
-        .setTargetSystemName("mipsel-linux-android")
-        .setTargetCpu("mips")
-        .setCompiler("gcc-4.8")
-
-        .addAllToolPath(ndkPaths.createToolpaths(
-            "mipsel-linux-android-4.8", "mipsel-linux-android",
-            // gcc-4.8 mips toolchain doesn't have dwp or gcov-tool.
-            CppConfiguration.Tool.DWP,
-            CppConfiguration.Tool.GCOVTOOL))
-
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-                "mipsel-linux-android-4.8", "mipsel-linux-android", "4.8"))
-
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips")));
-
-    builder.add(createMipsToolchain()
-        .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",
-            // gcc-4.9 mips toolchain doesn't have the dwp tool.
-            CppConfiguration.Tool.DWP))
-
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            "mipsel-linux-android-4.9", "mipsel-linux-android", "4.9"))
-
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips")));
+    builder.add(
+        createMipsToolchain()
+            .setToolchainIdentifier("mipsel-linux-android-4.8")
+            .setTargetSystemName("mipsel-linux-android")
+            .setTargetCpu("mips")
+            .setCompiler("gcc-4.8")
+
+            .addAllToolPath(
+                ndkPaths.createToolpaths(
+                    "mipsel-linux-android-4.8",
+                    "mipsel-linux-android",
+                    // gcc-4.8 mips toolchain doesn't have dwp or gcov-tool.
+                    CppConfiguration.Tool.DWP,
+                    CppConfiguration.Tool.GCOVTOOL))
+
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths(
+                    "mipsel-linux-android-4.8", "mipsel-linux-android", "4.8"))
+
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips"))
+
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "mipsel-linux-android-4.8")
+            .setDynamicRuntimesFilegroup("static-runtime-libs-" + "mipsel-linux-android-4.8"));
+
+    builder.add(
+        createMipsToolchain()
+            .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",
+                    // gcc-4.9 mips toolchain doesn't have the dwp tool.
+                    CppConfiguration.Tool.DWP))
+
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths(
+                    "mipsel-linux-android-4.9", "mipsel-linux-android", "4.9"))
+
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips"))
+
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "mipsel-linux-android-4.9")
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + "mipsel-linux-android-4.9"));
 
     // The flags for mips clang 3.5 and 3.6 are the same, they differ only in the LLVM version
     // given in their tool paths.
     for (String clangVersion : new String[] { "3.5", "3.6" }) {
-      builder.add(createMipsClangToolchain("mips", "4.8")
-          .setToolchainIdentifier("mipsel-linux-android-clang" + clangVersion)
-          .setTargetSystemName("mipsel-linux-android")
-          .setTargetCpu("mips")
-          .setCompiler("gcc-4.8")
-
-          .addAllToolPath(ndkPaths.createClangToolpaths(
-              "mipsel-linux-android-4.8", "mipsel-linux-android", clangVersion,
-              CppConfiguration.Tool.DWP, CppConfiguration.Tool.GCOVTOOL))
-
-          .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-              "mipsel-linux-android-4.8", "mipsel-linux-android", "4.8"))
-
-          .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips")));
+      String toolchainIdentifier = "mipsel-linux-android-clang" + clangVersion;
+      builder.add(
+          createMipsClangToolchain("mips", "4.8")
+              .setToolchainIdentifier(toolchainIdentifier)
+              .setTargetSystemName("mipsel-linux-android")
+              .setTargetCpu("mips")
+              .setCompiler("gcc-4.8")
+
+              .addAllToolPath(
+                  ndkPaths.createClangToolpaths(
+                      "mipsel-linux-android-4.8",
+                      "mipsel-linux-android",
+                      clangVersion,
+                      CppConfiguration.Tool.DWP,
+                      CppConfiguration.Tool.GCOVTOOL))
+
+              .addAllCxxBuiltinIncludeDirectory(
+                  ndkPaths.createToolchainIncludePaths(
+                      "mipsel-linux-android-4.8", "mipsel-linux-android", "4.8"))
+
+              .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("mips"))
+
+              .setSupportsEmbeddedRuntimes(true)
+              .setStaticRuntimesFilegroup("static-runtime-libs-" + toolchainIdentifier)
+              .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + toolchainIdentifier));
     }
 
     return builder.build();
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/X86Crosstools.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/X86Crosstools.java
index f3c99bb8d9..bbbed4e62a 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/X86Crosstools.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/android/ndkcrosstools/X86Crosstools.java
@@ -40,87 +40,116 @@ class X86Crosstools {
      * x86
      */
 
-    builder.add(createBaseX86Toolchain()
-        .setToolchainIdentifier("x86-4.8")
-        .setTargetCpu("x86")
-        .setCompiler("gcc-4.8")
+    builder.add(
+        createBaseX86Toolchain()
+            .setToolchainIdentifier("x86-4.8")
+            .setTargetCpu("x86")
+            .setCompiler("gcc-4.8")
 
-        .addAllToolPath(ndkPaths.createToolpaths(
-            "x86-4.8", "i686-linux-android",
-            // gcc-4.8 x86 toolchain doesn't have gcov-tool.
-            CppConfiguration.Tool.GCOVTOOL))
-        
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            "x86-4.8", "i686-linux-android", "4.8"))
+            .addAllToolPath(
+                ndkPaths.createToolpaths(
+                    "x86-4.8",
+                    "i686-linux-android",
+                    // gcc-4.8 x86 toolchain doesn't have gcov-tool.
+                    CppConfiguration.Tool.GCOVTOOL))
 
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths("x86-4.8", "i686-linux-android", "4.8"))
 
-        .addCompilerFlag("-fstack-protector"));
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
 
-    builder.add(createBaseX86Toolchain()
-        .setToolchainIdentifier("x86-4.9")
-        .setTargetCpu("x86")
-        .setCompiler("gcc-4.9")
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "x86-4.8")
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + "x86-4.8")
 
-        .addAllToolPath(ndkPaths.createToolpaths(
-            "x86-4.9", "i686-linux-android"))
+            .addCompilerFlag("-fstack-protector"));
 
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            "x86-4.9", "i686-linux-android", "4.9"))
+    builder.add(
+        createBaseX86Toolchain()
+            .setToolchainIdentifier("x86-4.9")
+            .setTargetCpu("x86")
+            .setCompiler("gcc-4.9")
 
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
+            .addAllToolPath(ndkPaths.createToolpaths("x86-4.9", "i686-linux-android"))
 
-        .addCompilerFlag("-fstack-protector-strong"));
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths("x86-4.9", "i686-linux-android", "4.9"))
 
-    // Add Clang toolchains. x86 uses gcc-4.8.
-    for (String clangVersion : new String[] { "3.5", "3.6" }) {      
-      builder.add(createX86ClangToolchain("x86", "i686", "4.8")
-          .setToolchainIdentifier("x86-clang" + clangVersion)
-          .setTargetCpu("x86")
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
 
-          .addAllToolPath(ndkPaths.createClangToolpaths(
-              "x86-4.8", "i686-linux-android", clangVersion,
-              // gcc-4.8 x86 toolchain doesn't have gcov-tool.
-              CppConfiguration.Tool.GCOVTOOL))
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "x86-4.9")
+            .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + "x86-4.9")
 
-          .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-              "x86-4.8", "i686-linux-android", "4.8"))
+            .addCompilerFlag("-fstack-protector-strong"));
 
-          .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86")));
+    // Add Clang toolchains. x86 uses gcc-4.8.
+    for (String clangVersion : new String[] { "3.5", "3.6" }) {      
+      builder.add(
+          createX86ClangToolchain("x86", "i686", "4.8")
+              .setToolchainIdentifier("x86-clang" + clangVersion)
+              .setTargetCpu("x86")
+
+              .addAllToolPath(
+                  ndkPaths.createClangToolpaths(
+                      "x86-4.8",
+                      "i686-linux-android",
+                      clangVersion,
+                      // gcc-4.8 x86 toolchain doesn't have gcov-tool.
+                      CppConfiguration.Tool.GCOVTOOL))
+
+              .addAllCxxBuiltinIncludeDirectory(
+                  ndkPaths.createToolchainIncludePaths("x86-4.8", "i686-linux-android", "4.8"))
+
+              .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86"))
+
+              .setSupportsEmbeddedRuntimes(true)
+              .setStaticRuntimesFilegroup("static-runtime-libs-" + "x86-clang" + clangVersion)
+              .setDynamicRuntimesFilegroup("dynamic-runtime-libs-" + "x86-clang" + clangVersion));
     }
 
     /**
      * x86_64
      */
 
-    builder.add(createBaseX86Toolchain()
-        .setToolchainIdentifier("x86_64-4.9")
-        .setTargetCpu("x86_64")
-        .setCompiler("gcc-4.9")
+    builder.add(
+        createBaseX86Toolchain()
+            .setToolchainIdentifier("x86_64-4.9")
+            .setTargetCpu("x86_64")
+            .setCompiler("gcc-4.9")
+
+            .addAllToolPath(ndkPaths.createToolpaths("x86_64-4.9", "x86_64-linux-android"))
 
-        .addAllToolPath(ndkPaths.createToolpaths(
-            "x86_64-4.9", "x86_64-linux-android"))
+            .addAllCxxBuiltinIncludeDirectory(
+                ndkPaths.createToolchainIncludePaths("x86_64-4.9", "x86_64-linux-android", "4.9"))
 
-        .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-            "x86_64-4.9", "x86_64-linux-android", "4.9"))
+            .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64"))
 
-        .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64"))
+            .setSupportsEmbeddedRuntimes(true)
+            .setStaticRuntimesFilegroup("static-runtime-libs-" + "x86_64-4.9")
+            .setDynamicRuntimesFilegroup("static-runtime-libs-" + "x86_64-4.9")
 
-        .addCompilerFlag("-fstack-protector-strong"));
+            .addCompilerFlag("-fstack-protector-strong"));
 
     // Add Clang toolchains. x86_64 uses gcc-4.9.
     for (String clangVersion : new String[] { "3.5", "3.6" }) {
-      builder.add(createX86ClangToolchain("x86_64", "x86_64", "4.9")
-          .setToolchainIdentifier("x86_64-clang" + clangVersion)
-          .setTargetCpu("x86_64")
+      builder.add(
+          createX86ClangToolchain("x86_64", "x86_64", "4.9")
+              .setToolchainIdentifier("x86_64-clang" + clangVersion)
+              .setTargetCpu("x86_64")
+
+              .addAllToolPath(
+                  ndkPaths.createClangToolpaths("x86_64-4.9", "x86_64-linux-android", clangVersion))
 
-          .addAllToolPath(ndkPaths.createClangToolpaths(
-              "x86_64-4.9", "x86_64-linux-android", clangVersion))
+              .addAllCxxBuiltinIncludeDirectory(
+                  ndkPaths.createToolchainIncludePaths("x86_64-4.9", "x86_64-linux-android", "4.9"))
 
-          .addAllCxxBuiltinIncludeDirectory(ndkPaths.createToolchainIncludePaths(
-              "x86_64-4.9", "x86_64-linux-android", "4.9"))
+              .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64"))
 
-          .setBuiltinSysroot(ndkPaths.createBuiltinSysroot("x86_64")));
+              .setSupportsEmbeddedRuntimes(true)
+              .setStaticRuntimesFilegroup("static-runtime-libs-" + "x86_64-clang" + clangVersion)
+              .setDynamicRuntimesFilegroup(
+                  "dynamic-runtime-libs-" + "x86_64-clang" + clangVersion));
     }
 
     ImmutableList<CToolchain.Builder> toolchainBuilders = builder.build();
diff --git a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
index 5cd41f3913..496ada0f09 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
@@ -115,9 +115,15 @@ public abstract class NativeDepsHelper {
     Artifact nativeDeps = ruleContext.getPackageRelativeArtifact(nativeDepsPath,
         configuration.getBinDirectory());
 
-    return createNativeDepsAction(ruleContext, linkParams, extraLinkOpts, configuration,
-        CppHelper.getToolchain(ruleContext), nativeDeps,
-        ruleContext.getConfiguration().getBinDirectory());
+    return createNativeDepsAction(
+        ruleContext,
+        linkParams,
+        extraLinkOpts,
+        configuration,
+        CppHelper.getToolchain(ruleContext),
+        nativeDeps,
+        ruleContext.getConfiguration().getBinDirectory(), /*useDynamicRuntime*/
+        true);
   }
 
   private static final String ANDROID_UNIQUE_DIR = "nativedeps";
@@ -153,15 +159,30 @@ public abstract class NativeDepsHelper {
         configuration.getBinDirectory());
 
     return createNativeDepsAction(
-        ruleContext, linkParams, /** extraLinkOpts */ImmutableList.<String>of(),
-        configuration, toolchain, nativeDeps, configuration.getBinDirectory()).getLibrary();
+            ruleContext,
+            linkParams, /** extraLinkOpts */
+            ImmutableList.<String>of(),
+            configuration,
+            toolchain,
+            nativeDeps,
+            configuration.getBinDirectory(),
+            /*useDynamicRuntime*/ false)
+        .getLibrary();
   }
 
-  private static NativeDepsRunfiles createNativeDepsAction(final RuleContext ruleContext,
-      CcLinkParams linkParams, Collection<String> extraLinkOpts, BuildConfiguration configuration,
-      CcToolchainProvider toolchain, Artifact nativeDeps, Root bindirIfShared) {
-    Preconditions.checkState(ruleContext.isLegalFragment(CppConfiguration.class),
-        "%s does not have access to CppConfiguration", ruleContext.getRule().getRuleClass());
+  private static NativeDepsRunfiles createNativeDepsAction(
+      final RuleContext ruleContext,
+      CcLinkParams linkParams,
+      Collection<String> extraLinkOpts,
+      BuildConfiguration configuration,
+      CcToolchainProvider toolchain,
+      Artifact nativeDeps,
+      Root bindirIfShared,
+      boolean useDynamicRuntime) {
+    Preconditions.checkState(
+        ruleContext.isLegalFragment(CppConfiguration.class),
+        "%s does not have access to CppConfiguration",
+        ruleContext.getRule().getRuleClass());
     List<String> linkopts = new ArrayList<>(extraLinkOpts);
     linkopts.addAll(linkParams.flattenedLinkopts());
 
@@ -182,38 +203,49 @@ public abstract class NativeDepsHelper {
         : nativeDeps;
     CppLinkAction.Builder builder = new CppLinkAction.Builder(
         ruleContext, sharedLibrary, configuration, toolchain);
-    builder.setLinkArtifactFactory(SHAREABLE_LINK_ARTIFACT_FACTORY);
-    CppLinkAction linkAction = builder
-        .setCrosstoolInputs(toolchain.getLink())
-        .addLibraries(linkerInputs)
-        .setLinkType(LinkTargetType.DYNAMIC_LIBRARY)
-        .setLinkStaticness(LinkStaticness.MOSTLY_STATIC)
-        .addLinkopts(linkopts)
-        .setNativeDeps(true)
-        .setRuntimeInputs(
-            toolchain.getDynamicRuntimeLinkMiddleman(), toolchain.getDynamicRuntimeLinkInputs())
-        .addLinkstamps(linkstamps)
-        .build();
+    if (useDynamicRuntime) {
+      builder.setRuntimeInputs(
+          toolchain.getDynamicRuntimeLinkMiddleman(), toolchain.getDynamicRuntimeLinkInputs());
+    } else {
+      builder.setRuntimeInputs(
+          toolchain.getStaticRuntimeLinkMiddleman(), toolchain.getStaticRuntimeLinkInputs());
+    }
+    CppLinkAction linkAction =
+        builder
+            .setLinkArtifactFactory(SHAREABLE_LINK_ARTIFACT_FACTORY)
+            .setCrosstoolInputs(toolchain.getLink())
+            .addLibraries(linkerInputs)
+            .setLinkType(LinkTargetType.DYNAMIC_LIBRARY)
+            .setLinkStaticness(LinkStaticness.MOSTLY_STATIC)
+            .addLinkopts(linkopts)
+            .setNativeDeps(true)
+            .addLinkstamps(linkstamps)
+            .build();
 
     ruleContext.registerAction(linkAction);
-    final Artifact linkerOutput = linkAction.getPrimaryOutput();
-
-    List<Artifact> runtimeSymlinks = new LinkedList<>();
+    Artifact linkerOutput = linkAction.getPrimaryOutput();
 
     if (shareNativeDeps) {
       // Collect dynamic-linker-resolvable symlinks for C++ runtime library dependencies.
       // Note we only need these symlinks when --share_native_deps is on, as shared native deps
       // mangle path names such that the library's conventional _solib RPATH entry
       // no longer resolves (because the target directory's relative depth gets lost).
-      for (final Artifact runtimeInput : toolchain.getDynamicRuntimeLinkInputs()) {
-        final Artifact runtimeSymlink = ruleContext.getPackageRelativeArtifact(
-            getRuntimeLibraryPath(ruleContext, runtimeInput), bindirIfShared);
-        // Since runtime library symlinks are underneath the target's output directory and
-        // multiple targets may share the same output directory, we need to make sure this
-        // symlink's generating action is only set once.
-        ruleContext.registerAction(
-            new SymlinkAction(ruleContext.getActionOwner(), runtimeInput, runtimeSymlink, null));
-        runtimeSymlinks.add(runtimeSymlink);
+      List<Artifact> runtimeSymlinks;
+      if (useDynamicRuntime) {
+        runtimeSymlinks = new LinkedList<>();
+        for (final Artifact runtimeInput : toolchain.getDynamicRuntimeLinkInputs()) {
+          final Artifact runtimeSymlink =
+              ruleContext.getPackageRelativeArtifact(
+                  getRuntimeLibraryPath(ruleContext, runtimeInput), bindirIfShared);
+          // Since runtime library symlinks are underneath the target's output directory and
+          // multiple targets may share the same output directory, we need to make sure this
+          // symlink's generating action is only set once.
+          ruleContext.registerAction(
+              new SymlinkAction(ruleContext.getActionOwner(), runtimeInput, runtimeSymlink, null));
+          runtimeSymlinks.add(runtimeSymlink);
+        }
+      } else {
+        runtimeSymlinks = ImmutableList.of();
       }
 
       ruleContext.registerAction(
@@ -221,7 +253,7 @@ public abstract class NativeDepsHelper {
       return new NativeDepsRunfiles(nativeDeps, runtimeSymlinks);
     }
 
-    return new NativeDepsRunfiles(linkerOutput, runtimeSymlinks);
+    return new NativeDepsRunfiles(linkerOutput, ImmutableList.<Artifact>of());
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsRunfiles.java b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsRunfiles.java
index cf51ff2cb4..db59fa1236 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsRunfiles.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsRunfiles.java
@@ -14,6 +14,7 @@
 
 package com.google.devtools.build.lib.rules.nativedeps;
 
+import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
@@ -40,7 +41,7 @@ public class NativeDepsRunfiles {
 
   public NativeDepsRunfiles(@Nullable Artifact library, @Nullable List<Artifact> runtimeSymlinks) {
     this.library = library;
-    this.runtimeSymlinks = runtimeSymlinks;
+    this.runtimeSymlinks = runtimeSymlinks == null ? null : ImmutableList.copyOf(runtimeSymlinks);
   }
 
   /**