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 #   visibility
  27 #   source_prereqs
  28 #   deps
  29 #   args   (all optional)
  30 #       Same meaning as action/action_foreach.
  31 #
  32 #
  33 # Example of usage:
  34 #
  35 #   compiled_action("run_my_tool") {
  36 #     tool = "//tools/something:mytool"
  37 #     outputs = [
  38 #       "$target_gen_dir/mysource.cc",
  39 #       "$target_gen_dir/mysource.h",
  40 #     ]
  41 #
  42 #     # The tool takes this input.
  43 #     source_prereqs = [ "my_input_file.idl" ]
  44 #
  45 #     # In this case, the tool takes as arguments the input file and the output
  46 #     # build dir (both relative to the "cd" that the script will be run in)
  47 #     # and will produce the output files listed above.
  48 #     args = [
  49 #       rebase_path("my_input_file.idl", root_build_dir),
  50 #       "--output-dir", rebase_path(target_gen_dir, root_build_dir),
  51 #     ]
  52 #   }
  53 #
  54 # You would typically declare your tool like this:
  55 #   if (host_toolchain == current_toolchain) {
  56 #     executable("mytool") {
  57 #       ...
  58 #     }
  59 #   }
  60 # The if statement around the executable is optional. That says "I only care
  61 # about this target in the host toolchain". Usually this is what you want, and
  62 # saves unnecessarily compiling your tool for the target platform. But if you
  63 # need a target build of your tool as well, just leave off the if statement.
  64
  65 template("compiled_action") {
  66   assert(defined(invoker.tool), "tool must be defined for $target_name")
  67   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
  68   assert(defined(invoker.args), "args must be defined for $target_name")
  69
  70   action(target_name) {
  71     if (defined(invoker.visibility)) {
  72       visibility = invoker.visibility
  73     }
  74
  75     script = "//build/gn_run_binary.py"
  76
  77     if (defined(invoker.source_prereqs)) {
  78       source_prereqs = invoker.source_prereqs
  79     }
  80     outputs = invoker.outputs
  81
  82     # Constuct the host toolchain version of the tool.
  83     host_tool = invoker.tool + "($host_toolchain)"
  84
  85     # Get the path to the executable. Currently, this assumes that the tool
  86     # does not specify output_name so that the target name is the name to use.
  87     # If that's not the case, we'll need another argument to the script to
  88     # specify this, since we can't know what the output name is (it might be in
  89     # another file not processed yet).
  90     host_executable = get_label_info(host_tool, "root_out_dir") + "/" +
  91       get_label_info(host_tool, "name")
  92
  93     deps = [ host_tool ]
  94     if (defined(invoker.deps)) {
  95       deps += invoker.deps
  96     }
  97
  98     # The script takes as arguments the binary to run, and then the arguments
  99     # to pass it.
 100     args = [
 101       rebase_path(host_executable, root_build_dir)
 102     ] + invoker.args
 103   }
 104 }
 105
 106 template("compiled_action_foreach") {
 107   assert(defined(invoker.sources), "sources must be defined for $target_name")
 108   assert(defined(invoker.tool), "tool must be defined for $target_name")
 109   assert(defined(invoker.outputs), "outputs must be defined for $target_name")
 110   assert(defined(invoker.args), "args must be defined for $target_name")
 111
 112   action_foreach(target_name) {
 113     # Otherwise this is a standalone action, define visibility if requested.
 114     if (defined(invoker.visibility)) {
 115       visibility = invoker.visibility
 116     }
 117
 118     script = "//build/gn_run_binary.py"
 119     sources = invoker.sources
 120
 121     if (defined(invoker.source_prereqs)) {
 122       source_prereqs = invoker.source_prereqs
 123     }
 124     outputs = invoker.outputs
 125
 126     # Constuct the host toolchain version of the tool.
 127     host_tool = invoker.tool + "($host_toolchain)"
 128
 129     # Get the path to the executable. Currently, this assumes that the tool
 130     # does not specify output_name so that the target name is the name to use.
 131     # If that's not the case, we'll need another argument to the script to
 132     # specify this, since we can't know what the output name is (it might be in
 133     # another file not processed yet).
 134     host_executable = get_label_info(host_tool, "root_out_dir") + "/" +
 135       get_label_info(host_tool, "name")
 136
 137     deps = [ host_tool ]
 138     if (defined(invoker.deps)) {
 139       deps += invoker.deps
 140     }
 141
 142     # The script takes as arguments the binary to run, and then the arguments
 143     # to pass it.
 144     args = [
 145       rebase_path(host_executable, root_build_dir)
 146     ] + invoker.args
 147   }
 148 }