build/compiled_action.gni

   1 # Copyright 2014 The Chromium Authors
   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 #   depfile
  32 #   deps
  33 #   visibility   (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     forward_variables_from(invoker,
  85                            [
  86                              "data_deps",
  87                              "deps",
  88                              "depfile",
  89                              "inputs",
  90                              "outputs",
  91                              "testonly",
  92                              "visibility",
  93                            ])
  94     if (!defined(deps)) {
  95       deps = []
  96     }
  97     if (!defined(inputs)) {
  98       inputs = []
  99     }
 100
 101     script = "//build/gn_run_binary.py"
 102
 103     # Constuct the host toolchain version of the tool.
 104     host_tool = invoker.tool + "($host_toolchain)"
 105
 106     # Get the path to the executable. Currently, this assumes that the tool
 107     # does not specify output_name so that the target name is the name to use.
 108     # If that's not the case, we'll need another argument to the script to
 109     # specify this, since we can't know what the output name is (it might be in
 110     # another file not processed yet).
 111     host_executable =
 112         get_label_info(host_tool, "root_out_dir") + "/" +
 113         get_label_info(host_tool, "name") + _host_executable_suffix
 114
 115     deps += [ host_tool ]
 116
 117     # The script takes as arguments the binary to run, and then the arguments
 118     # to pass it.
 119     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 120   }
 121 }
 122
 123 template("compiled_action_foreach") {
 124   assert(defined(invoker.sources), "sources must be defined for $target_name")
 125   assert(defined(invoker.tool), "tool must be defined for $target_name")
 126   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
 127   assert(defined(invoker.args), "args must be defined for $target_name")
 128
 129   action_foreach(target_name) {
 130     forward_variables_from(invoker,
 131                            [
 132                              "deps",
 133                              "depfile",
 134                              "inputs",
 135                              "outputs",
 136                              "sources",
 137                              "testonly",
 138                              "visibility",
 139                            ])
 140     if (!defined(deps)) {
 141       deps = []
 142     }
 143     if (!defined(inputs)) {
 144       inputs = []
 145     }
 146
 147     script = "//build/gn_run_binary.py"
 148
 149     # Constuct the host toolchain version of the tool.
 150     host_tool = invoker.tool + "($host_toolchain)"
 151
 152     # Get the path to the executable. Currently, this assumes that the tool
 153     # does not specify output_name so that the target name is the name to use.
 154     # If that's not the case, we'll need another argument to the script to
 155     # specify this, since we can't know what the output name is (it might be in
 156     # another file not processed yet).
 157     host_executable =
 158         get_label_info(host_tool, "root_out_dir") + "/" +
 159         get_label_info(host_tool, "name") + _host_executable_suffix
 160
 161     deps += [ host_tool ]
 162
 163     # The script takes as arguments the binary to run, and then the arguments
 164     # to pass it.
 165     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 166   }
 167 }