| #!/bin/bash |
| # Copyright 2017 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| ### set up a build directory |
| |
| ## usage: fx set TARGET [OUTDIR] |
| ## [--board NAME|PATH] |
| ## [--product NAME|PATH] |
| ## [--monolith PATH] |
| ## [--preinstall PATH] |
| ## [--available PATH] |
| ## [--netboot] |
| ## [--args ARG] [--help-args [ARG]] [--variant VARIANT] |
| ## [--goma|--no-goma] [--no-ensure-goma] |
| ## [--goma-dir DIR] |
| ## [--ccache|--no-ccache] |
| ## [--release] |
| ## [--zircon-arg ARG] |
| ## |
| ## where TARGET is x64 or arm64 |
| ## |
| ## OUTDIR is the directory where the build output goes. |
| ## If it begins with `//` or `out/` then it's taken as relative to FUCHSIA_DIR. |
| ## Otherwise it should be an absolute path or a path relative to the current |
| ## working directory that winds up in `FUCHSIA_DIR/out`. |
| ## It defaults to `out/TARGET`. |
| ## |
| ## This is a wrapper around running `gn gen --check OUTDIR --args ...`. |
| ## If GN fails with an error, `fx set` does not change anything. |
| ## If GN succeeds, this also points subsequent `fx` commands at OUTDIR, |
| ## just as `fx use` does and ensures Goma is ready (if enabled). |
| ## |
| ## NAME|PATH can be provided as arugments to --board and --product. In the |
| ## case of NAME the name is searched for in //layer/board/NAME.gni, otherwise it |
| ## is treated as a PATH. |
| ## |
| ## optional arguments: |
| ## --board Use the given board target definition. Board |
| ## configurations are used to modulate hardware specific |
| ## behavior, such as configuring the set of drivers |
| ## included, or adding peripheral specific configurations. |
| ## If no board is given, a default board for the architecture |
| ## is selected from the current layer, e.g. |
| ## garnet/boards/x64.gni. |
| ## --product Include the given product in the build. Defaults to |
| ## the default product for the current layer (e.g., |
| ## "garnet/products/default.gni" for the Garnet layer). |
| ## Product configurations define a set of packages to be |
| ## included in the monolith, preinstall and available |
| ## package sets, as well as product oriented configurations. |
| ## --monolith Additional packages to be built and included in the |
| ## monolithic system image. Monolith is the set of packages |
| ## that make up an OTA image. |
| ## If the --monolith argument is given multiple times, |
| ## all the specified packages are included in this set. |
| ## These packages are added to the available set defined |
| ## by the board and product specifications. |
| ## --preinstall Additional packages to be built and included in the |
| ## system image alongside the monolithic system image. |
| ## Packages in preinstall are not part of OTA updates, |
| ## instead they are updated dynamically. |
| ## If the --preinstall argument is given multiple times, |
| ## all the specified packages are included in this set. |
| ## These packages are added to the available set defined |
| ## by the board and product specifications. |
| ## --available Additional packages to be built and included in the |
| ## set of packages available for pushing dynamically. |
| ## If the --available argument is given multiple times, |
| ## all the specified available are included in this set. |
| ## These packages are added to the available set defined |
| ## by the board and product specifications. |
| ## --netboot Ensure that a network ramboot image is always built. |
| ## --variant Pass a `select_variant=[VARIANT*,...]` GN build argument |
| ## collecting all the --variant arguments in order. |
| ## --fuzz-with Pass a sanitizer name, e.g. "--fuzz-with asan" to |
| ## enable ALL supporting fuzzers. Use --variant for |
| ## individual fuzzers, e.g. "--variant asan-fuzzer/foo". |
| ## --args Additional argument to pass to gn. If the --args |
| ## argument is given multiple times, all the specified |
| ## arguments are passed to gn. |
| ## N.B. Arguments must be expressed using GN's syntax. |
| ## In particular this means that for strings they must |
| ## be quoted with double-quotes, and the quoting must |
| ## survive, for example, the shell. Thus when passing |
| ## an argument that takes a string, pass it with |
| ## something like --args=foo='"bar"'. E.g., |
| ## bash$ fx set x64 --args=foo='"bar"' |
| ## More complicated arguments, e.g., lists, require |
| ## their own special syntax. See GN documentation |
| ## for the syntax of each kind of argument. |
| ## --help-args Display GN arguments documentation. If --help-args |
| ## is followed by a GN build argument identifier, just |
| ## that argument's documentation is displayed. |
| ## If --help-args is used alone, all GN build arguments |
| ## are displayed (lots of output). |
| ## This option requires an existing build directory. |
| ## --goma|--no-goma Whether to use the goma service during the build. Goma |
| ## attempts to make builds faster using remote build |
| ## servers. Defaults to detecting whether goma is installed |
| ## on your machine. |
| ## --no-ensure-goma Skip ensuring that goma is started when using goma. |
| ## --goma-dir The directory where goma is installed. Defaults to |
| ## ~/goma. |
| ## --ccache|--no-ccache Whether to use ccache during the build. Ccache attempts |
| ## to make builds faster by caching build artifacts. |
| ## Defaults to detecting whether the CCACHE_DIR environment |
| ## variable is set to a directory. |
| ## --ide Pass --ide=VALUE to gn when generating to create project |
| ## files usable with that IDE. Useful values include "vs" |
| ## for Visual Studio or "xcode" for Xcode. |
| ## --release an alias for "--args=is_debug=false" |
| ## |
| ## Deprecated flags: |
| ## |
| ## --boards Use the listed board target definition (seperated by |
| ## comas) in the build, each board results in an import |
| ## statement and MUST define the `fuchsia_packages` |
| ## variable as well as deal with variable re-definition. |
| ## This flag is deprecated, please use --board instead. |
| ## --products Include the listed products (separated by commas) in |
| ## the build. Defaults to the default product for the |
| ## current layer (e.g., "garnet/packages/default.gni" for |
| ## the Garnet layer). If the --products argument is |
| ## given multiple times, the products configurations |
| ## are merged. |
| ## This flag is deprecated, please use exactly one |
| ## --product and specify packages to add in addition to |
| ## the product with --packages. |
| ## --packages Additional packages to be built and made available. |
| ## If the --packages argument is given multiple times, |
| ## all the specified packages are included in the |
| ## build. |
| ## This flag is deprecated, please use one of |
| ## --available, --preinstall, or --monolith. |
| ## --zircon-arg ARG Additional arguments to pass to Zircon make. Can be given |
| ## multiple times. |
| ## |
| ## Example: |
| ## |
| ## $ fx set x64 kitchensink --product ermine --available topaz/packages/kitchen_sink |
| ## -> architecture: x64 |
| ## build directory: out/kitchensink |
| ## board: topaz/boards/x64.gni |
| ## product: topaz/products/ermine.gni |
| ## available: topaz/packages/kitchen_sink (all other packages) |
| |
| source "$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"/lib/vars.sh || exit $? |
| |
| function guess_config_within_layer { |
| local config_type="$1" |
| local config_name="$2" |
| local __resultvar="$3" |
| |
| # Guess the petal we're using. We'll search at this petal and below for |
| # config matching the type and short name |
| local current_petal |
| current_petal="$(${FUCHSIA_DIR}/build/gn/guess_layer.py)" || return 1 |
| readonly current_petal |
| |
| # Compute a lookup order starting at the current petal going down. |
| local petal_order="${current_petal}" |
| case $current_petal in |
| vendor/*) |
| petal_order="${petal_order},topaz,peridot,garnet" |
| ;; |
| "topaz") |
| petal_order="${petal_order},peridot,garnet" |
| ;; |
| "peridot") |
| petal_order="${petal_order},garnet" |
| ;; |
| esac |
| readonly petal_order |
| |
| # Look through petals in this order to find configs with matching names. |
| IFS=, |
| local petal |
| for petal in $petal_order; do |
| guessed_config="${petal}/${config_type}/${config_name}.gni" |
| if [[ -a "${FUCHSIA_DIR}/${guessed_config}" ]]; then |
| echo "Guessing ${config_type} config ${guessed_config}" |
| eval "${__resultvar}"="${guessed_config}" |
| return |
| fi |
| done |
| |
| echo "Could not guess a ${config_type} configuration matching \"${config_name}\"" |
| echo "Please specify the full path from the root of the checkout such as" |
| echo "garnet/${config_type}/base.gni" |
| exit 1 |
| } |
| |
| |
| function main { |
| fx-standard-switches "$@" |
| set -- "${FX_ARGV[@]}" |
| |
| if [[ $# -lt 1 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| |
| local arch= |
| case $1 in |
| x64 | x86 | x64-64) |
| arch=x64 |
| ;; |
| arm64 | aarch64) |
| arch=arm64 |
| ;; |
| *) |
| # TODO(alainv): Add support for extracting arch from board configs. |
| echo Unknown target \"$1\" |
| fx-command-help |
| return 1 |
| ;; |
| esac |
| shift |
| |
| cd "${FUCHSIA_DIR}" |
| |
| local gn_cmd='gen' |
| local -a gn_switches=(--check) |
| local gn_args="target_cpu=\"${arch}\"" |
| local boards=() |
| local products=() |
| local available=() |
| local preinstall=() |
| local monolith=() |
| local packages=() |
| local zircon_args=() |
| local extra_packages=() |
| local build_dir= |
| local variant= |
| local use_goma |
| local goma_dir |
| local ensure_goma=1 |
| local ccache |
| while [[ $# -ne 0 ]]; do |
| case "$1" in |
| --board) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| boards+=("$2") |
| shift |
| ;; |
| --product) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| products+=("$2") |
| shift |
| ;; |
| --available) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS=, available+=("$2") |
| shift |
| ;; |
| --preinstall) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS=, preinstall+=("$2") |
| shift |
| ;; |
| --monolith) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS=, monolith+=("$2") |
| shift |
| ;; |
| --boards) |
| echo >&2 "--boards is deprecated, --board is preferred" |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| # Multiple boards may be comma separated |
| IFS=, boards+=("$2") |
| shift |
| ;; |
| --products) |
| echo >&2 "--products is deprecated, --product is preferred" |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| # Multiple products may be comma separated |
| IFS=, products+=("$2") |
| shift |
| ;; |
| --packages) |
| echo >&2 "--packages is deprecated, --monolith, --preinstall or --available are preferred" |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| # Multiple packages may be comma separated |
| IFS=, packages+=("$2") |
| shift |
| ;; |
| --zircon-arg) |
| echo >&2 "--zircon-arg is deprecated, common use case is no longer required" |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| zircon_args+=("$2") |
| shift |
| ;; |
| --netboot) |
| extra_packages+=('build/packages/netboot') |
| ;; |
| --goma) |
| use_goma=1 |
| ;; |
| --no-goma) |
| use_goma=0 |
| ;; |
| --no-ensure-goma) |
| ensure_goma=0 |
| ;; |
| --goma-dir) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| goma_dir=$2 |
| if [[ ! -d "${goma_dir}" ]]; then |
| echo -e "error: GOMA directory does not exist: "${goma_dir}"" |
| return 1 |
| fi |
| shift |
| ;; |
| --release) |
| gn_args+=" is_debug=false" |
| ;; |
| --variant) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| variant+="\"$2\"," |
| shift |
| ;; |
| --fuzz-with) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| variant+="{variant=\"$2-fuzzer\" target_type=[\"fuzzed_executable\"]}," |
| shift |
| ;; |
| --args) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| gn_args+=" $2" |
| shift |
| ;; |
| --help-args) |
| gn_cmd=args |
| if [[ $# -ge 2 ]] && [[ "$2" != '--*' ]]; then |
| gn_switches+=("--list=$2") |
| shift |
| else |
| gn_switches+=(--list) |
| fi |
| ;; |
| --ccache) |
| ccache=1 |
| ;; |
| --no-ccache) |
| ccache=0 |
| ;; |
| --ide) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| gn_switches+=("--ide=$2") |
| shift |
| ;; |
| --*) |
| fx-command-help |
| return 1 |
| ;; |
| *) |
| # A non-option argument is the build_dir, but there can be only one. |
| if [[ -n "$build_dir" ]]; then |
| fx-command-help |
| return 1 |
| fi |
| build_dir="$1" |
| ;; |
| esac |
| shift |
| done |
| |
| if [[ -z "${products}${packages}" ]]; then |
| # This is the default logic GN would use, but if a user specified --netboot |
| # we would short-circuit the logic, so repeat it here. |
| local layers |
| layers="$(${FUCHSIA_DIR}/build/gn/guess_layer.py)" || return 1 |
| readonly layers |
| local layer |
| for layer in $layers; do |
| products+="${products:+,}$layer/products/default.gni" |
| done |
| fi |
| |
| if [[ -z "${boards}" ]]; then |
| # Import the board target definition from the current layer if it exists. |
| local layers |
| if [[ -z "${layers}" ]]; then |
| layers="$(${FUCHSIA_DIR}/build/gn/guess_layer.py)" || return 1 |
| fi |
| readonly layers |
| local layer |
| for layer in $layers; do |
| if [[ -e "$layer/boards/$arch.gni" ]]; then |
| boards+="${boards:+,}$layer/boards/$arch.gni" |
| fi |
| done |
| fi |
| |
| # Remove any trailing slash from build directory name. |
| build_dir="${build_dir%/}" |
| |
| local config_build_dir |
| case "$build_dir" in |
| '') |
| # Default is "//out/$target_cpu". Store it as relative. |
| config_build_dir="out/${arch}" |
| build_dir="${FUCHSIA_DIR}/${config_build_dir}" |
| ;; |
| //*|out/*) |
| # GN-style "source-relative" path or relative out/something. |
| config_build_dir="${build_dir#//}" |
| build_dir="${FUCHSIA_DIR}/${config_build_dir}" |
| ;; |
| *) |
| # Absolute or relative path. Canonicalize it to source-relative. |
| local abs_build_dir |
| abs_build_dir="$(cd "${build_dir%/*}" >/dev/null 2>&1; pwd)/${build_dir##*/}" || { |
| echo >&2 "ERROR: Missing parent directories for ${build_dir}" |
| return 1 |
| } |
| if [[ "$abs_build_dir" == "${FUCHSIA_DIR}"/out/* ]]; then |
| config_build_dir="${abs_build_dir#${FUCHSIA_DIR}/}" |
| else |
| echo >&2 "WARNING: ${abs_build_dir} is not a subdirectory of ${FUCHSIA_DIR}/out" |
| config_build_dir="$abs_build_dir" |
| fi |
| ;; |
| esac |
| |
| # If a goma directory wasn't specified explicitly then default to "~/goma". |
| if [[ -z "${goma_dir}" ]]; then |
| goma_dir="$HOME/goma" |
| fi |
| |
| # Automatically detect goma and ccache if not specified explicitly. |
| if [[ -z "${use_goma}" ]] && [[ -z "${ccache}" ]]; then |
| if [[ -d "${goma_dir}" ]]; then |
| use_goma=1 |
| elif [[ -n "${CCACHE_DIR}" ]] && [[ -d "${CCACHE_DIR}" ]]; then |
| ccache=1 |
| fi |
| fi |
| |
| for board in ${boards[@]}; do |
| if [[ ! -a "${FUCHSIA_DIR}/${board}" ]]; then |
| local guessed_board="" |
| guess_config_within_layer "boards" "${board}" guessed_board |
| board="${guessed_board}" |
| fi |
| gn_args+=" import(\"//${board}\")" |
| done |
| |
| # Add goma or ccache settings as appropriate. |
| if [[ "${use_goma}" -eq 1 ]]; then |
| gn_args+=" use_goma=true goma_dir=\"${goma_dir}\"" |
| elif [[ "${ccache}" -eq 1 ]]; then |
| gn_args+=" use_ccache=true" |
| fi |
| |
| for product in ${products[@]}; do |
| if [[ ! -a "${FUCHSIA_DIR}/${product}" ]]; then |
| local guessed_product="" |
| guess_config_within_layer "products" "${product}" guessed_product |
| product="${guessed_product}" |
| fi |
| gn_args+=" import(\"//${product}\")" |
| done |
| |
| # Board configs MUST declare fuchsia_packages, and boards must be non-empty. |
| gn_args+=" fuchsia_packages+=[" |
| for package in ${packages[@]} ${extra_packages[@]}; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="]" |
| |
| gn_args+=" if (!defined(available)) { available = [] }" |
| gn_args+=" available+=[" |
| for package in ${available[@]}; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="]" |
| |
| gn_args+=" if (!defined(preinstall)) { preinstall = [] }" |
| gn_args+=" preinstall+=[" |
| for package in ${preinstall[@]}; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="]" |
| gn_args+=" if (!defined(monolith)) { monolith = [] }" |
| gn_args+=" monolith+=[" |
| for package in ${monolith[@]}; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="]" |
| |
| if [[ -n "${variant}" ]]; then |
| gn_args+=" select_variant=[${variant}]" |
| fi |
| |
| mkdir -p "${build_dir}" |
| echo "${zircon_args[@]}" > "${build_dir}.zircon-args" |
| |
| # Using a subshell with -x prints out the gn command precisely with shell |
| # quoting so a cut&paste to the command line works. Always show the real |
| # meaning of what this script does so everyone learns how GN works. |
| ( |
| set -x |
| "${FUCHSIA_DIR}/buildtools/gn" ${gn_cmd} "${build_dir}" \ |
| "${gn_switches[@]}" --args="${gn_args}" "$@" |
| # If GN failed, don't update .config. |
| ) || return |
| |
| fx-config-write "${config_build_dir}" |
| |
| if [[ "${use_goma}" -eq 1 ]] && [[ "${ensure_goma}" -eq 1 ]]; then |
| if ! [[ $("${goma_dir}/gomacc" port) =~ ^[0-9]+$ ]]; then |
| "${goma_dir}/goma_ctl.py" ensure_start || return $? |
| fi |
| fi |
| } |
| |
| main "$@" |
