blob: 97b2b44f1ac51c122d2415071a02358aa702ba7d [file] [log] [blame]
# Copyright (c) 2020 Project CHIP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build_overrides/build.gni")
# Convert a binary to a target format using objcopy.
template("objcopy_convert") {
forward_variables_from(invoker,
[
"conversion_input",
"conversion_output",
"conversion_target_format",
"deps",
"objcopy",
])
action(target_name) {
inputs = [ conversion_input ]
outputs = [ conversion_output ]
args = [
objcopy,
"-O",
conversion_target_format,
rebase_path(conversion_input, root_build_dir),
rebase_path(conversion_output, root_build_dir),
]
script = "${build_root}/gn_run_binary.py"
}
}
# Build a script to perform a device flashing operation.
#
# This requires a Python script, given by flashing_script_generator,
# to construct the resulting flashing script, given by flashing_script_name.
#
# As used by flashable_executable(), the generator script requires two options,
# --output SCRIPT - The generated script
# --application IMAGE - The file to be flashed
# plus any platform- or target-specific options as passed in by
# flashable_executable()'s flashing_options.
template("gen_flashing_script") {
forward_variables_from(invoker,
[
"flashing_script_generator",
"flashing_script_name",
"flashing_script_inputs",
"flashing_options",
"deps",
"data_deps",
])
action(target_name) {
outputs = [ flashing_script_name ]
args = flashing_options
args += [
"--output",
rebase_path(flashing_script_name, root_build_dir),
]
script = flashing_script_generator
inputs = flashing_script_inputs
}
}
# Build target for an executable, optionally converted to the preferred form
# for flashing, plus a script that performs the flashing operation.
#
# The intent is that every flashable (or testable) build target in CHIP will
# ultimately be flashable/runnable in a consistent way.
template("flashable_executable") {
executable_target = "$target_name.executable"
if (defined(invoker.flashing_script_name)) {
# Generating the flashing script is the final target.
final_target = "$target_name.flashing"
} else if (defined(invoker.objcopy_image_name)) {
# Converted image is the final target.
final_target = "$target_name.image"
} else {
# The executable is the final target.
final_target = executable_target
}
if (defined(invoker.flashbundle_name)) {
flashbundle_name = invoker.flashbundle_name
} else {
flashbundle_name = "${target_name}.flashbundle.txt"
}
group(target_name) {
data_deps = [ ":$final_target" ]
if (defined(invoker.data_deps)) {
data_deps += invoker.data_deps
}
write_runtime_deps = "${root_out_dir}/${flashbundle_name}"
}
if (defined(invoker.objcopy_image_name)) {
# Executable target must be converted for flashing.
assert(defined(invoker.objcopy_image_format))
assert(defined(invoker.objcopy))
image_target = "$target_name.image"
image_name = invoker.objcopy_image_name
image_format = invoker.objcopy_image_format
objcopy = invoker.objcopy
objcopy_convert(image_target) {
conversion_input = "${root_out_dir}/${invoker.output_name}"
conversion_output = "${root_out_dir}/${image_name}"
conversion_target_format = image_format
deps = [ ":$executable_target" ]
}
}
if (defined(invoker.flashing_script_name)) {
if (!defined(image_target)) {
# The executable can be flashed directly.
image_target = executable_target
image_name = invoker.output_name
}
gen_flashing_script("$target_name.flashing") {
flashing_script_generator = invoker.flashing_script_generator
flashing_script_inputs = invoker.flashing_script_inputs
flashing_script_name = "$root_out_dir/${invoker.flashing_script_name}"
if (defined(invoker.flashing_options)) {
flashing_options = invoker.flashing_options
} else {
flashing_options = []
}
flashing_options += [
"--application",
rebase_path(image_name, root_out_dir, root_out_dir),
]
data_deps = [ ":$image_target" ]
}
}
executable(executable_target) {
forward_variables_from(invoker, "*")
}
}