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 (build_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     if (defined(invoker.visibility)) {
  85       visibility = invoker.visibility
  86     }
  87
  88     script = "//build/gn_run_binary.py"
  89
  90     if (defined(invoker.inputs)) {
  91       inputs = invoker.inputs
  92     } else {
  93       inputs = []
  94     }
  95     outputs = invoker.outputs
  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 = [
 113       host_tool,
 114     ]
 115     if (defined(invoker.deps)) {
 116       deps += invoker.deps
 117     }
 118
 119     # The script takes as arguments the binary to run, and then the arguments
 120     # to pass it.
 121     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 122   }
 123 }
 124
 125 template("compiled_action_foreach") {
 126   assert(defined(invoker.sources), "sources must be defined for $target_name")
 127   assert(defined(invoker.tool), "tool must be defined for $target_name")
 128   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
 129   assert(defined(invoker.args), "args must be defined for $target_name")
 130
 131   action_foreach(target_name) {
 132     # Otherwise this is a standalone action, define visibility if requested.
 133     if (defined(invoker.visibility)) {
 134       visibility = invoker.visibility
 135     }
 136
 137     script = "//build/gn_run_binary.py"
 138     sources = invoker.sources
 139
 140     if (defined(invoker.inputs)) {
 141       inputs = invoker.inputs
 142     } else {
 143       inputs = []
 144     }
 145     outputs = invoker.outputs
 146
 147     # Constuct the host toolchain version of the tool.
 148     host_tool = invoker.tool + "($host_toolchain)"
 149
 150     # Get the path to the executable. Currently, this assumes that the tool
 151     # does not specify output_name so that the target name is the name to use.
 152     # If that's not the case, we'll need another argument to the script to
 153     # specify this, since we can't know what the output name is (it might be in
 154     # another file not processed yet).
 155     host_executable =
 156         get_label_info(host_tool, "root_out_dir") + "/" +
 157         get_label_info(host_tool, "name") + _host_executable_suffix
 158
 159     # Add the executable itself as an input.
 160     inputs += [ host_executable ]
 161
 162     deps = [
 163       host_tool,
 164     ]
 165     if (defined(invoker.deps)) {
 166       deps += invoker.deps
 167     }
 168
 169     # The script takes as arguments the binary to run, and then the arguments
 170     # to pass it.
 171     args = [ rebase_path(host_executable, root_build_dir) ] + invoker.args
 172   }
 173 }