build/compiled_action.gni

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 # This file introduces two related templates that act like action and
   6 # action_foreach but instead of running a Python script, it will compile a
   7 # given tool in the host toolchain and run that (either once or over the list
   8 # of inputs, depending on the variant).
   9 #
  10 # Parameters
  11 #
  12 #   tool (required)
  13 #       [label] Label of the tool to run. This should be an executable, and
  14 #       this label should not include a toolchain (anything in parens). The
  15 #       host compile of this tool will be used.
  16 #
  17 #   outputs (required)
  18 #       [list of files] Like the outputs of action (if using "compiled_action",
  19 #       this would be just the list of outputs), or action_foreach (if using
  20 #       "compiled_action_foreach", this would contain source expansions mapping
  21 #       input to output files).
  22 #
  23 #   args (required)
  24 #       [list of strings] Same meaning as action/action_foreach.
  25 #
  26 #   inputs (optional)
  27 #       Files the binary takes as input. The step will be re-run whenever any
  28 #       of these change. If inputs is empty, the step will run only when the
  29 #       binary itself changes.
  30 #
  31 #   visibility
  32 #   deps
  33 #   args   (all optional)
  34 #       Same meaning as action/action_foreach.
  35 #
  36 #
  37 # Example of usage:
  38 #
  39 #   compiled_action("run_my_tool") {
  40 #     tool = "//tools/something:mytool"
  41 #     outputs = [
  42 #       "$target_gen_dir/mysource.cc",
  43 #       "$target_gen_dir/mysource.h",
  44 #     ]
  45 #
  46 #     # The tool takes this input.
  47 #     inputs = [ "my_input_file.idl" ]
  48 #
  49 #     # In this case, the tool takes as arguments the input file and the output
  50 #     # build dir (both relative to the "cd" that the script will be run in)
  51 #     # and will produce the output files listed above.
  52 #     args = [
  53 #       rebase_path("my_input_file.idl", root_build_dir),
  54 #       "--output-dir", rebase_path(target_gen_dir, root_build_dir),
  55 #     ]
  56 #   }
  57 #
  58 # You would typically declare your tool like this:
  59 #   if (host_toolchain == current_toolchain) {
  60 #     executable("mytool") {
  61 #       ...
  62 #     }
  63 #   }
  64 # The if statement around the executable is optional. That says "I only care
  65 # about this target in the host toolchain". Usually this is what you want, and
  66 # saves unnecessarily compiling your tool for the target platform. But if you
  67 # need a target build of your tool as well, just leave off the if statement.
  68
  69 if (host_os == "win") {
  70   _host_executable_suffix = ".exe"
  71 } else {
  72   _host_executable_suffix = ""
  73 }
  74
  75 template("compiled_action") {
  76   assert(defined(invoker.tool), "tool must be defined for $target_name")
  77   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
  78   assert(defined(invoker.args), "args must be defined for $target_name")
  79
  80   assert(!defined(invoker.sources),
  81          "compiled_action doesn't take a sources arg. Use inputs instead.")
  82
  83   action(target_name) {
  84     deps = []
  85     inputs = []
  86     forward_variables_from(invoker,
  87                            [
  88                              "deps",
  89                              "inputs",
  90                              "outputs",
  91                              "testonly",
  92                              "visibility",
  93                            ])
  94
  95     script = "//build/gn_run_binary.py"
  96
  97     # Constuct the host toolchain version of the tool.
  98     host_tool = invoker.tool + "($host_toolchain)"
  99
 100     # Get the path to the executable. Currently, this assumes that the tool
 101     # does not specify output_name so that the target name is the name to use.
 102     # If that's not the case, we'll need another argument to the script to
 103     # specify this, since we can't know what the output name is (it might be in
 104     # another file not processed yet).
 105     host_executable =
 106         get_label_info(host_tool, "root_out_dir") + "/" +
 107         get_label_info(host_tool, "name") + _host_executable_suffix
 108
 109     # Add the executable itself as an input.
 110     inputs += [ host_executable ]
 111
 112     deps += [ host_tool ]
 113
 114     # The script takes as arguments the binary to run, and then the arguments
 115     # to pass it.
 116     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 117   }
 118 }
 119
 120 template("compiled_action_foreach") {
 121   assert(defined(invoker.sources), "sources must be defined for $target_name")
 122   assert(defined(invoker.tool), "tool must be defined for $target_name")
 123   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
 124   assert(defined(invoker.args), "args must be defined for $target_name")
 125
 126   action_foreach(target_name) {
 127     deps = []
 128     inputs = []
 129     forward_variables_from(invoker,
 130                            [
 131                              "deps",
 132                              "inputs",
 133                              "outputs",
 134                              "sources",
 135                              "testonly",
 136                              "visibility",
 137                            ])
 138
 139     script = "//build/gn_run_binary.py"
 140
 141     # Constuct the host toolchain version of the tool.
 142     host_tool = invoker.tool + "($host_toolchain)"
 143
 144     # Get the path to the executable. Currently, this assumes that the tool
 145     # does not specify output_name so that the target name is the name to use.
 146     # If that's not the case, we'll need another argument to the script to
 147     # specify this, since we can't know what the output name is (it might be in
 148     # another file not processed yet).
 149     host_executable =
 150         get_label_info(host_tool, "root_out_dir") + "/" +
 151         get_label_info(host_tool, "name") + _host_executable_suffix
 152
 153     # Add the executable itself as an input.
 154     inputs += [ host_executable ]
 155
 156     deps += [ host_tool ]
 157
 158     # The script takes as arguments the binary to run, and then the arguments
 159     # to pass it.
 160     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 161   }
 162 }