gn build: Upgrade to NDK r19.

[pcc]

Summary

NDK r19 includes a sysroot that can be used directly by the compiler
without creating a standalone toolchain, so we just need a handful
of flags to point Clang there.

[thakis]

Nice!

Do you know if we do this in chrome already?

llvm/utils/gn/build/toolchain/target_flags.gni

11 ↗

(On Diff #185222)

What do we need the -B for btw? We use integrated-as and everything, right?

[pcc]

In D57733#1384600, @thakis wrote:

Nice!

Do you know if we do this in chrome already?

Chrome is on r16 and doesn't use standalone toolchains, and I believe that it's doing something very similar to what we used to be doing here (e.g. https://cs.chromium.org/chromium/src/build/config/android/config.gni?type=cs&q=4%5C.9%5C.x&sq=package:chromium&g=0&l=319 to find libgcc).

llvm/utils/gn/build/toolchain/target_flags.gni

11 ↗

(On Diff #185222)

The -B is needed to let the driver find libgcc which lives in a target-specific directory under toolchains/llvm/prebuilt/linux-x86_64/lib/gcc. I don't think it's used for anything else.

It looks it would have also worked to put libgcc in the sysroot (e.g. the aarch64 one could have lived in toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android), then there would be no need to pass -B as well. In fact if I try copying libgcc there and remove the -B here then I can still compile and link things and check-hwasan still passes. @danalbert do you know why it wasn't done that way?

compiler-rt/trunk/CMakeLists.txt

if (${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "^arm")
     set(COMPILER_RT_DEFAULT_TARGET_ARCH "armhf")
   endif()
 endif()
 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*android.*")
   set(ANDROID 1)
 endif()
 pythonize_bool(ANDROID)
 
+set(ANDROID_NDK_VERSION 18
+    CACHE STRING "Set this to the Android NDK version that you are using")
+
 set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 pythonize_bool(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
 
 # We support running instrumented tests when we're not cross compiling
 # and target a UNIX-like system or Windows.
 # We can run tests on Android even when we are cross-compiling.

compiler-rt/trunk/test/hwasan/TestCases/sizes.cpp

-// RUN: %clangxx_hwasan %s -lstdc++ -o %t
+// This test requires operator new to be intercepted by the hwasan runtime,
+// so we need to avoid linking against libc++.
+// RUN: %clangxx_hwasan %s -nostdlib++ -lstdc++ -o %t
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t malloc 2>&1          | FileCheck %s --check-prefix=CHECK-max
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t malloc 2>&1
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t malloc max 2>&1      | FileCheck %s --check-prefix=CHECK-max
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t malloc max 2>&1
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t calloc 2>&1          | FileCheck %s --check-prefix=CHECK-calloc
 // RUN: %env_hwasan_opts=allocator_may_return_null=1     %run %t calloc 2>&1
 // RUN: %env_hwasan_opts=allocator_may_return_null=0 not %run %t new 2>&1             | FileCheck %s --check-prefix=CHECK-max
 // RUN: %env_hwasan_opts=allocator_may_return_null=1 not %run %t new 2>&1             | FileCheck %s --check-prefix=CHECK-oom

compiler-rt/trunk/test/lit.common.cfg

 if config.asan_shadow_scale != '':
   config.target_cflags += " -mllvm -asan-mapping-scale=" + config.asan_shadow_scale
 
 # BFD linker in 64-bit android toolchains fails to find libc++_shared.so, which
 # is a transitive shared library dependency (via asan runtime).
 if config.android:
   # Prepend the flag so that it can be overridden.
   config.target_cflags = "-pie -fuse-ld=gold " + config.target_cflags
+  if config.android_ndk_version < 19:
+    # With a new compiler and NDK < r19 this flag ends up meaning "link against
+    # libc++", but NDK r19 makes this mean "link against the stub libstdc++ that
+    # just contains a handful of ABI functions", which makes most C++ code fail
+    # to link. In r19 and later we just use the default which is libc++.
     config.cxx_mode_flags.append('-stdlib=libstdc++')
 
 # Clear some environment variables that might affect Clang.
 possibly_dangerous_env_vars = ['ASAN_OPTIONS', 'DFSAN_OPTIONS', 'LSAN_OPTIONS',
                                'MSAN_OPTIONS', 'UBSAN_OPTIONS',
                                'COMPILER_PATH', 'RC_DEBUG_OPTIONS',
                                'CINDEXTEST_PREAMBLE_FILE', 'LIBRARY_PATH',
                                'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
                                'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',

compiler-rt/trunk/test/lit.common.configured.in

 set_default("sanitizer_can_use_cxxabi", @SANITIZER_CAN_USE_CXXABI_PYBOOL@)
 set_default("has_lld", @COMPILER_RT_HAS_LLD_PYBOOL@)
 set_default("can_symbolize", @CAN_SYMBOLIZE@)
 set_default("use_lld", False)
 set_default("use_thinlto", False)
 set_default("use_lto", config.use_thinlto)
 set_default("use_newpm", False)
 set_default("android", @ANDROID_PYBOOL@)
+set_default("android_ndk_version", @ANDROID_NDK_VERSION@)
 set_default("android_serial", "@ANDROID_SERIAL_FOR_TESTING@")
 set_default("android_files_to_push", [])
 set_default("have_rpc_xdr_h", @HAVE_RPC_XDR_H@)
 config.available_features.add('target-is-%s' % config.target_arch)
 
 if config.enable_per_target_runtime_dir:
   set_default("target_suffix", "")
 else:

llvm/trunk/utils/gn/build/BUILD.gn

 import("//llvm/utils/gn/build/buildflags.gni")
 import("//llvm/utils/gn/build/mac_sdk.gni")
 import("//llvm/utils/gn/build/toolchain/compiler.gni")
 import("//llvm/utils/gn/build/toolchain/target_flags.gni")
 
 config("compiler_defaults") {
   defines = []
 
   if (!llvm_enable_assertions) {
     defines += [ "NDEBUG" ]
   }
 
-  cflags = target_flags + target_cflags
+  cflags = target_flags
   ldflags = target_flags + target_ldflags
 
   if (host_os == "mac" && clang_base_path != "") {
     cflags += [
       "-isysroot",
       mac_sdk_path,
     ]
   }

llvm/trunk/utils/gn/build/toolchain/compiler.gni

 declare_args() {
   # Whether to use goma (https://chromium.googlesource.com/infra/goma/client/)
   use_goma = false
 
   # Set this to a clang build directory. If set, that clang is used as compiler.
   # goma only works with compiler binaries it knows about, so useful both for
   # using a goma-approved compiler and for compiling clang with a locally-built
   # clang in a different build directory.
   # On Windows, setting this also causes lld-link to be used as linker.
   # Example value: getenv("HOME") + "/src/llvm-build/Release+Asserts"
   clang_base_path = ""
 
-  # Set this to the path to Android NDK r18b. If set, cross compilation targeting
+  # Set this to the path to Android NDK r19. If set, cross compilation targeting
   # Android will be enabled.
   android_ndk_path = ""
 }
 
 declare_args() {
   # Set if the host compiler is clang.  On by default on Mac or if
   # clang_base_path is set.
   is_clang = host_os == "mac" || clang_base_path != ""
 
   # Set this to true to link with LLD instead of the default linker.
   use_lld = clang_base_path != "" && host_os != "mac"
 }

llvm/trunk/utils/gn/build/toolchain/target_flags.gni

 import("//llvm/triples.gni")
 import("//llvm/utils/gn/build/toolchain/compiler.gni")
 
 target_flags = []
-target_cflags = []
 target_ldflags = []
 
 if (current_os == "android") {
-  assert(current_cpu == "arm64", "current_cpu not supported")
-
-  libcxx_path = "$android_ndk_path/sources/cxx-stl/llvm-libc++"
-  platform_lib_path =
-      "$android_ndk_path/platforms/android-21/arch-arm64/usr/lib"
-  libgcc_path = "$android_ndk_path/toolchains/aarch64-linux-android-4.9/prebuilt/linux-x86_64/lib/gcc/aarch64-linux-android/4.9.x"
-
   target_flags += [
     "--target=$llvm_current_triple",
-    "--sysroot=$android_ndk_path/sysroot",
-  ]
-  target_cflags += [
-    "-isystem",
-    "$libcxx_path/include",
-  ]
-  target_ldflags += [
-    "-B$platform_lib_path",
-    "-L$platform_lib_path",
-    "-L$libgcc_path",
-  ]
-  target_ldflags += [
-    "-nostdlib++",
-    "-L$libcxx_path/libs/arm64-v8a",
-    "-l:libc++.a.21",
+    "--sysroot=$android_ndk_path/toolchains/llvm/prebuilt/linux-x86_64/sysroot",
+    "-B$android_ndk_path/toolchains/llvm/prebuilt/linux-x86_64",
   ]
+  target_ldflags += [ "-static-libstdc++" ]
 }

llvm/trunk/utils/gn/secondary/compiler-rt/test/BUILD.gn

values = [
     "COMPILER_RT_DEBUG_PYBOOL=False",
     "COMPILER_RT_RESOLVED_LIBRARY_OUTPUT_DIR=" +
         rebase_path(crt_current_out_dir),
     "COMPILER_RT_EMULATOR=",
     "COMPILER_RT_ASAN_SHADOW_SCALE=",
     "SANITIZER_CAN_USE_CXXABI_PYBOOL=True",
     "COMPILER_RT_HAS_LLD_PYBOOL=True",
     "HAVE_RPC_XDR_H=0",
+    "ANDROID_NDK_VERSION=19",
     "ANDROID_SERIAL_FOR_TESTING=$android_serial_for_testing",
   ]
 
   if (host_cpu == "x64") {
     values += [ "HOST_ARCH=x86_64" ]
   } else {
     assert(false, "unimplemented host_cpu " + host_cpu)
   }

llvm/trunk/utils/gn/secondary/compiler-rt/test/test.gni

 import("//llvm/utils/gn/build/toolchain/target_flags.gni")
 
 declare_args() {
   # Specifies the serial number of the Android device to be used for testing.
   android_serial_for_testing = ""
 }
 
 target_flags_string = ""
 
-foreach(flag,
-        target_flags + target_cflags + target_ldflags + [ "-fuse-ld=lld" ]) {
+foreach(flag, target_flags + target_ldflags + [ "-fuse-ld=lld" ]) {
   if (target_flags_string != "") {
     target_flags_string += " "
   }
   target_flags_string += flag
 }