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