gn build: Rename llvm_host_triple to llvm_current_triple and have it use current_{cpu,os}.

[pcc]

Summary

This makes e.g. ToolChain::isCrossCompiling() in
clang/lib/Driver/ToolChain.cpp return the correct result
if the compiler was cross-compiled. This change also affects
llvm_default_target_triple, so cross-compiled compilers default to
targeting the cross-compilation target, which makes more sense than
the host that the compiler was compiled on.

This change will also be necessary in order for the correct triples
to appear in generated lit files for non-native targets.

[phosek]

llvm/utils/gn/secondary/llvm/triples.gni

21

Rather than replacing llvm_host_triple with llvm_current_triple, I think we should have both. This is going to be needed in some places, e.g. libc++, libc++abi, and libunwind lit configuration uses the host as well as the target triple, see https://github.com/llvm/llvm-project/blob/master/libcxx/test/lit.site.cfg.in#L18.

[pcc]

llvm/utils/gn/secondary/llvm/triples.gni

21

All of the current users want llvm_current_triple; let's add llvm_host_triple later if we need it. Taking a quick look at libc++ for example, it's not clear that host_triple is actually being used for anything, so we might end up removing it from the template instead of adding it for the sake of those projects.

[phosek]

LGTM

llvm/utils/gn/build/BUILDCONFIG.gn

 
 if (target_os == "") {
   target_os = host_os
 }
 if (current_os == "") {
   current_os = target_os
 }
 
+if (target_cpu == "") {
+  target_cpu = host_cpu
+}
+if (current_cpu == "") {
+  current_cpu = target_cpu
+}
+
 if (host_os == "win") {
   host_toolchain = "//llvm/utils/gn/build/toolchain:win"
 } else {
   host_toolchain = "//llvm/utils/gn/build/toolchain:unix"
 }
 
 set_default_toolchain(host_toolchain)

llvm/utils/gn/build/toolchain/BUILD.gn

if (use_goma) {
     cc = "$goma_dir/gomacc $cc"
     cxx = "$goma_dir/gomacc $cxx"
   }
 
   ar = "ar"
 
   toolchain_args = {
     current_os = host_os
+    current_cpu = host_cpu
   }
 }
 
 if (android_ndk_path != "") {
   unix_toolchain("stage2_android_aarch64") {
     cc = "bin/clang"
     cxx = "bin/clang++"
     ld = cxx
     ar = "bin/llvm-ar"
 
     deps = [
       "//:clang($host_toolchain)",
       "//:lld($host_toolchain)",
       "//:llvm-ar($host_toolchain)",
     ]
 
     toolchain_args = {
       current_os = "android"
+      current_cpu = "arm64"
     }
 
     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 =
toolchain("win") {
 
   tool("stamp") {
     command = "cmd /c type nul > {{output}}"
     description = "STAMP {{output}}"
   }
 
   toolchain_args = {
     current_os = "win"
+    current_cpu = host_cpu
   }
 }

llvm/utils/gn/secondary/clang/test/BUILD.gn

extra_values = [
     # This is only used if LLVM_USE_SANITIZER includes lsan and the host
     # OS is macOS. Since the GN build currently never uses LLVM_USE_SANITIZER,
     # this is never read.  If it's ever needed,
     # utils/gn/build/toolchain/BUILD.gn should get the compiler from a variable
     # that's also read here -- but that should happen after multi-toolchain
     # builds exist, to make sure it's a toolchain var.
     "CMAKE_CXX_COMPILER=c++",
     "ENABLE_BACKTRACES=1",
-    "LLVM_HOST_TRIPLE=$llvm_host_triple",
+    "LLVM_HOST_TRIPLE=$llvm_current_triple",
     "LLVM_LIT_TOOLS_DIR=",  # Intentionally empty, matches cmake build.
     "LLVM_USE_SANITIZER=",
     "PYTHON_EXECUTABLE=$python_path",
     "USE_Z3_SOLVER=",
   ]
 
   if (clang_enable_arcmt) {
     extra_values += [ "CLANG_ENABLE_ARCMT=1" ]

llvm/utils/gn/secondary/llvm/include/llvm/Config/BUILD.gn

 write_cmake_config("llvm-config") {
   input = "llvm-config.h.cmake"
   output = "$target_gen_dir/llvm-config.h"
   values = [
     "LLVM_ENABLE_DUMP=",
     "LINK_POLLY_INTO_TOOLS=",
     "LLVM_DEFAULT_TARGET_TRIPLE=$llvm_target_triple",
     "LLVM_HAS_ATOMICS=1",
-    "LLVM_HOST_TRIPLE=$llvm_host_triple",
+    "LLVM_HOST_TRIPLE=$llvm_current_triple",
     "LLVM_NATIVE_ARCH=$native_target",
     "LLVM_NATIVE_ASMPARSER=1",
     "LLVM_NATIVE_ASMPRINTER=1",
     "LLVM_NATIVE_DISASSEMBLER=1",
     "LLVM_NATIVE_TARGET=1",
     "LLVM_NATIVE_TARGETINFO=1",
     "LLVM_NATIVE_TARGETMC=1",
     "LLVM_USE_INTEL_JITEVENTS=",

llvm/utils/gn/secondary/llvm/test/BUILD.gn

extra_values = [
 
     # Only used by the Go bindings tests, and for detecting a 32-bit build
     # and in a belt-and-suspenders check for detecting 32-bit host builds.
     # (That check also checks LLVM_HOST_TRIPLE.)
     "HOST_LDFLAGS=",
 
     "LLVM_ENABLE_FFI=0",
     "LLVM_HAVE_OPT_VIEWER_MODULES=0",
-    "LLVM_HOST_TRIPLE=$llvm_host_triple",
+    "LLVM_HOST_TRIPLE=$llvm_current_triple",
     "LLVM_LIBRARY_DIR=" + rebase_path("$root_out_dir/lib"),
     "LLVM_LINK_LLVM_DYLIB=0",
     "LLVM_LIT_TOOLS_DIR=",  # Intentionally empty, matches cmake build.
     "LLVM_NATIVE_ARCH=$native_target",
     "LLVM_TOOL_LTO_BUILD=1",  # The GN build always builds //llvm/tools/lto.
     "LLVM_USE_INTEL_JITEVENTS=0",
     "LLVM_USE_SANITIZER=",
     "PYTHON_EXECUTABLE=$python_path",

llvm/utils/gn/secondary/llvm/triples.gni

-if (host_cpu == "x64") {
-  if (host_os == "linux") {
-    llvm_host_triple = "x86_64-unknown-linux-gnu"
-  } else if (host_os == "mac") {
-    llvm_host_triple = "x86_64-apple-darwin"
-  } else if (host_os == "win") {
-    llvm_host_triple = "x86_64-pc-windows"
+if (current_cpu == "x64") {
+  if (current_os == "linux") {
+    llvm_current_triple = "x86_64-unknown-linux-gnu"
+  } else if (current_os == "mac") {
+    llvm_current_triple = "x86_64-apple-darwin"
+  } else if (current_os == "win") {
+    llvm_current_triple = "x86_64-pc-windows"
   }
-} else {
-  assert(false, "unimplemented host_cpu " + host_cpu)
+} else if (current_cpu == "arm64") {
+  if (current_os == "android") {
+    llvm_current_triple = "aarch64-linux-android21"
+  }
+}
+
+if (!defined(llvm_current_triple)) {
+  assert(false, "unimplemented cpu/os " + current_cpu + "/" + current_os)
 }
 
 declare_args() {
   # The default target triple.
-  llvm_target_triple = llvm_host_triple
+  llvm_target_triple = llvm_current_triple
 }