[gn build] Extract compiled_action.gni from tablegen.gni

[thakis]

Summary

After years of tablegen being the only host binary we run as part
of the build, we're now in the process of growing at least two more:

• make_confusable_table (https://reviews.llvm.org/rG180bae08a04d)
• pseudo-gen (not yet fully hooked up in the GN build, but I have a local branch that hooks it up).

Factor our the few lines we need for running a host binary as part of the
build.

No behavior change.

[hans]

lgtm

Factor our the few lines we need for running a host binary as part of the

Ultra nit: factor *out*

[thakis]

Done.

Thanks!

llvm/utils/gn/build/compiled_action.gni

+# Defines compiled_action().
+#
+# compiled_action() is like action(), except that it runs a built binary
+# instead of a script.
+#
+# Parameters:
+#
+#   tool (required)
+#       [label] Label of the tool to run. This should be an executable, and
+#       this label should not include a toolchain (anything in parens). This
+#       tool will be built for the host.
+#
+#   outputs (required)
+#       [list of files] Same meaning as for action().
+#
+#   args (required)
+#       [list of strings] Flags to pass to the built binary. Almost identical
+#       to action()'s `args`, except that `tool` is implicitly added as first
+#       element.
+#
+#   depfile
+#   inputs
+#   public_configs
+#   visibility   (all optional)
+#       Same meaning as for action().
+#
+# Example use:
+#
+#   compiled_action("run_my_tool") {
+#     tool = "//tools/something:mytool"
+#     inputs = [ "my_input_file.txt" ]
+#     outputs = [ "$target_gen_dir/mysource.inc" ]
+#     args = [
+#       rebase_path(inputs[0], root_build_dir),
+#       rebase_path(outputs[0], root_build_dir),
+#     ]
+#   }
+#
+# You would typically declare your tool like this:
+#   if (host_toolchain == current_toolchain) {
+#     executable("mytool") {
+#       ...
+#     }
+#   }
+# The if statement around the executable is optional. It means "I only care
+# about this target in the host toolchain". Usually this is what you want, and
+# saves unnecessarily compiling your tool for the target platform. If you
+# need a target build of your tool as well, omit the if statement.
+
+template("compiled_action") {
+  assert(defined(invoker.args), "must set 'args' in $target_name")
+  assert(defined(invoker.outputs), "must set 'outputs' in $target_name")
+  assert(defined(invoker.tool), "must set 'tool' in $target_name")
+  assert(!defined(invoker.sources),
+         "use 'inputs' instead of 'sources' in $target_name")
+
+  action(target_name) {
+    forward_variables_from(invoker,
+                           [
+                             "depfile",
+                             "inputs",
+                             "outputs",
+                             "public_configs",
+                             "visibility",
+                           ])
+    host_tool = invoker.tool + "($host_toolchain)"
+    host_executable = get_label_info(host_tool, "root_out_dir") +
+                      "/bin/" + get_label_info(host_tool, "name")
+    deps = [ host_tool ]
+    script = "//llvm/utils/gn/build/run_built_binary.py"
+    args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
+  }
+}
+

llvm/utils/gn/build/run_built_binary.py

 #!/usr/bin/env python3
-"""Runs tablegen."""
+"""Runs a built binary."""
 
 import subprocess
 import sys
 
 # Prefix with ./ to run built binary, not arbitrary stuff from PATH.
 sys.exit(subprocess.call(['./' + sys.argv[1]] + sys.argv[2:]))

llvm/utils/gn/secondary/llvm/utils/TableGen/tablegen.gni

 # Example use:
 #
 #   tablegen("attributes_compat_func_gen") {
 #     visibility = [ ":IR" ]
 #     args = [ "-gen-attrs" ]
 #     td_file = "AttributesCompatFunc.td"
 #   }
 
+import("//llvm/utils/gn/build/compiled_action.gni")
+
 template("tablegen") {
   assert(defined(invoker.args), "must set 'args' in $target_name")
 
   config_name = "${target_name}_config"
   config(config_name) {
     visibility = [ ":$target_name" ]
     include_dirs = [ target_gen_dir ]
   }
 
-  action(target_name) {
+  compiled_action(target_name) {
     forward_variables_from(invoker, [ "visibility" ])
 
     if (defined(invoker.tblgen_target)) {
-      tblgen_target = invoker.tblgen_target
+      tool = invoker.tblgen_target
     } else {
-      tblgen_target = "//llvm/utils/TableGen:llvm-tblgen"
+      tool = "//llvm/utils/TableGen:llvm-tblgen"
     }
-    tblgen_target += "($host_toolchain)"
-    tblgen_executable = get_label_info(tblgen_target, "root_out_dir") +
-                        "/bin/" + get_label_info(tblgen_target, "name")
-    deps = [ tblgen_target ]
     if (defined(invoker.td_file)) {
       td_file = invoker.td_file
     } else {
       td_file = "$target_name.td"
     }
-    sources = [ td_file ]
-    script = "//llvm/utils/gn/build/run_tablegen.py"
+    inputs = [ td_file ]
     if (defined(invoker.output_name)) {
       gen_output = "$target_gen_dir/" + invoker.output_name
     } else {
       gen_output = "$target_gen_dir/$target_name.inc"
     }
     depfile = "$gen_output.d"
     td_file = rebase_path(td_file, root_build_dir)
 
     args = [
-             rebase_path(tblgen_executable, root_build_dir),
              "--write-if-changed",
 
              "-I",
              rebase_path("//llvm/include", root_build_dir),
 
              # FIXME: Rather than duplicating this -I flag in both the CMake and
              # the gn build, let tablegen add input dir to include search path
              # instead?