[gn build] Generalize use_goma to compiler_wrapper

[aeubanks]

Summary

e.g. ccache is much faster than goma if everything is already cached.

Also since goma is going away.

Users will need to specify compiler_wrapper = $prev_goma_dir/gomacc for the same behavior.

[aeubanks]

remove goma gn args

[aeubanks]

https://github.com/llvm/llvm-project/pull/72757

llvm/utils/gn/build/BUILD.gn

if (is_clang) {
           # in code like "A foo(ConvertibleToA a) { return std::move(a); }",
           # but this code does not compile (or uses the copy constructor
           # instead) on clang<=3.8. Clang also has a -Wredundant-move, but it
           # only fires when the types match exactly, so we can keep it here.
           "-Wno-redundant-move",
         ]
       }
     }
-    if (is_clang && use_goma) {
+    if (is_clang && compiler_wrapper != "") {
       # goma converts all paths to lowercase on the server, breaking this
       # warning.
       cflags += [ "-Wno-nonportable-include-path" ]
     }
   }
 
   # On Windows, the linker is not invoked through the compiler driver.
   if (use_lld && current_os != "win") {
if ((current_os == "ios" || current_os == "mac") &&
     ldflags += [
       "-isysroot",
       rebase_path(sdk_path, root_build_dir),
     ]
   }
   if (sysroot != "" && current_os != "win" && is_clang) {
     cflags += [ "-Wpoison-system-directories" ]
   }
-  assert(
-      !use_goma || sysroot != "",
-      "goma needs a sysroot: run `llvm/utils/sysroot.py make-fake --out-dir=sysroot` and add `sysroot = \"//sysroot\"` to your args.gn")
 
   if (use_ubsan) {
     assert(is_clang && (current_os == "ios" || current_os == "linux" ||
                             current_os == "mac"),
            "ubsan only supported on iOS/Clang, Linux/Clang, or macOS/Clang")
     cflags += [
       "-fsanitize=undefined",
       "-fno-sanitize-recover=all",

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

 import("//llvm/utils/gn/build/toolchain/compiler.gni")
 
-declare_args() {
-  # If is_goma is true, the location of the goma client install.
-  # Set this to the output of `goma_ctl goma_dir`.
-  goma_dir = ""
-}
-
-assert(!use_goma || goma_dir != "",
-       "set `goma_dir` to the output of `goma_ctl goma_dir` in your args.gn")
-
 unix_copy_command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})"
 
 template("unix_toolchain") {
   toolchain(target_name) {
     # https://groups.google.com/a/chromium.org/g/gn-dev/c/F_lv5T-tNDM
     forward_variables_from(invoker.toolchain_args, "*")
     not_needed("*")
 
     forward_variables_from(invoker, "*")
 
     cc = "cc"
     cxx = "c++"
 
     if (clang_base_path != "") {
       cc = rebase_path(clang_base_path, root_build_dir) + "/bin/clang"
       cxx = rebase_path(clang_base_path, root_build_dir) + "/bin/clang++"
     }
 
-    ld = cxx  # Don't use goma wrapper for linking.
-    if (use_goma) {
-      cc = "$goma_dir/gomacc $cc"
-      cxx = "$goma_dir/gomacc $cxx"
+    ld = cxx  # Don't use compiler wrapper for linking.
+    if (compiler_wrapper != "") {
+      cc = "$compiler_wrapper $cc"
+      cxx = "$compiler_wrapper $cxx"
     }
 
     tool("cc") {
       depfile = "{{output}}.d"
       command = "$cc -MMD -MF $depfile -o {{output}} -c {{source}} {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
       depsformat = "gcc"
       description = "CC {{output}}"
       outputs = [ "{{source_out_dir}}/{{label_name}}.{{source_name_part}}.o" ]

 # This template defines a toolchain that uses just-built clang and lld
 # as compiler and linker.
 template("stage2_unix_toolchain") {
   unix_toolchain(target_name) {
     toolchain_args = {
       forward_variables_from(invoker.toolchain_args, "*")
 
       clang_base_path = root_build_dir
-      use_goma = false
+      compiler_wrapper = ""
     }
 
     deps = [
       "//:clang($host_toolchain)",
       "//:lld($host_toolchain)",
     ]
     if (toolchain_args.current_os != "ios" &&
         toolchain_args.current_os != "mac") {
toolchain(target_name) {
 
     if (clang_base_path != "") {
       cl = rebase_path(clang_base_path, root_build_dir) + "/bin/clang-cl"
       if (use_lld) {
         link = rebase_path(clang_base_path, root_build_dir) + "/bin/lld-link"
       }
     }
 
-    if (use_goma) {
-      cl = "$goma_dir/gomacc $cl"
+    if (compiler_wrapper != "") {
+      cl = "$compiler_wrapper $cl"
     }
 
     tool("cc") {
       command = "$cl /nologo /showIncludes /Fo{{output}} /c {{source}} {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
       depsformat = "msvc"
       description = "CC {{output}}"
       outputs = [ "{{source_out_dir}}/{{label_name}}.{{source_name_part}}.obj" ]
     }
win_toolchain("stage2_win_x64") {
   toolchain_args = {
     current_os = "win"
     current_cpu = "x64"
 
     if (host_os != "win") {
       sysroot = win_sysroot
     }
     clang_base_path = root_build_dir
-    use_goma = false
+    compiler_wrapper = ""
   }
   deps = [
     "//:clang($host_toolchain)",
     "//:lld($host_toolchain)",
   ]
 }
 
 win_toolchain("stage2_win_x86") {
   toolchain_args = {
     current_os = "win"
     current_cpu = "x86"
 
     if (host_os != "win") {
       sysroot = win_sysroot
     }
     clang_base_path = root_build_dir
-    use_goma = false
+    compiler_wrapper = ""
   }
   deps = [
     "//:clang($host_toolchain)",
     "//:lld($host_toolchain)",
   ]
 }

llvm/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 r21. If set, cross compilation targeting
   # Android will be enabled.
   android_ndk_path = ""
 
   # Set this to the path of the Win SDK. Only used for cross compilation. If set, cross compilation targeting Windows will be enabled.
   win_sysroot = ""
+
+  # If set, prepends this to compile action command lines (e.g. `"ccache"`).
+  compiler_wrapper = ""
 }
 
 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 != ""
 }
 
 assert(
     !(host_os == "win" && win_sysroot != ""),
     "win_sysroot should only be used for cross compilation, use sysroot on Windows")