| # 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. |
| |
| import("//build/config/clang/clang.gni") |
| import("//build/config/fuchsia/zircon_legacy_vars.gni") |
| import("//build/config/sysroot.gni") |
| import("//build/fidl/wireformat.gni") |
| import("//build/host.gni") |
| import("//build/sdk/sdk_atom.gni") |
| |
| declare_args() { |
| # gocache_dir |
| # Directory GOCACHE environment variable will be set to. This directory |
| # will have build and test results cached, and is safe to be written to |
| # concurrently. If overridden, this directory must be a full path. |
| gocache_dir = rebase_path("$root_out_dir/.gocache") |
| |
| # go_vet_enabled |
| # [bool] if false, go vet invocations are disabled for all builds. |
| go_vet_enabled = false |
| } |
| |
| # A template for an action that builds a Go binary. Users should instead use the |
| # go_binary or go_test rules. |
| # |
| # Parameters |
| # |
| # gopackages (required) |
| # List of packages to build. |
| # |
| # sdk_category (optional) |
| # Publication level of the library in SDKs. |
| # See //build/sdk/sdk_atom.gni. |
| # |
| # deps (optional) |
| # List of labels representing go_library targets this target depends on. |
| # |
| # non_go_deps (optional) |
| # List of labels this target depends on that are not Go libraries. |
| # |
| # skip_vet (optional) |
| # Whether to skip running go vet for this target. This flag should _only_ |
| # be used for packages in the Go source tree itself that otherwise match |
| # whitelist entries in go vet all. Go vet is only run if go_vet_enabled is |
| # true. |
| # |
| # test (optional, default: false) |
| # Whether this target defines a test. |
| # |
| # carchive (optional, default: false) |
| # Whether to build this target as a C archive. |
| # |
| # tags (optional) |
| # List of go build tags to include in the build. |
| # |
| template("go_build") { |
| assert(defined(invoker.gopackages), |
| "gopackages must be defined for $target_name") |
| gopackages = invoker.gopackages |
| assert( |
| gopackages == [ gopackages[0] ], |
| "gopackages currently only supports one package because of http://crbug.com/fuchsia/8088") |
| |
| main_target_name = target_name |
| |
| is_test = defined(invoker.test) && invoker.test |
| carchive = defined(invoker.carchive) && invoker.carchive |
| |
| output_name = target_name |
| if (defined(invoker.output_name)) { |
| output_name = invoker.output_name |
| } |
| if (carchive) { |
| output_name = "${output_name}.a" |
| } |
| output_path = "${root_out_dir}/${output_name}" |
| |
| assert(!(is_test && carchive), |
| "cannot specify both test=true and carchive=true") |
| define_sdk_target = defined(invoker.sdk_category) && |
| invoker.sdk_category != "excluded" && !is_test |
| |
| # Strip target binaries and binaries that are included in the SDK. |
| use_strip = (is_fuchsia || define_sdk_target) && !carchive |
| if (use_strip) { |
| unstripped_output_path = "${root_out_dir}/exe.unstripped/${output_name}" |
| } |
| |
| # Detect whether we're building with a fuzzer toolchain config. For |
| # example, when go_fuzzer() compiles the Go fuzz target to be linked |
| # into the fuzzer() executable, and fx set --fuzz-with is in use. |
| is_fuzzer = false |
| foreach(config, toolchain_variant.configs) { |
| if (config == "//build/config/sanitizers:fuzzer") { |
| is_fuzzer = true |
| } |
| } |
| |
| action(main_target_name) { |
| deps = [] |
| if (defined(invoker.non_go_deps)) { |
| deps += invoker.non_go_deps |
| } |
| |
| pool = "//build/go:pool($default_toolchain)" |
| |
| outputs = [ |
| output_path, |
| ] |
| |
| if (use_strip) { |
| outputs += [ unstripped_output_path ] |
| } |
| |
| script = "//build/go/build.py" |
| depfile = "${output_path}.d" |
| |
| sources = [ |
| "//build/go/gen_library_metadata.py", |
| ] |
| |
| godepfile = "$host_out_dir/godepfile" |
| inputs = [ |
| godepfile, |
| ] |
| deps += [ "//tools/build/godepfile($host_toolchain)" ] |
| |
| args = [ |
| "--godepfile", |
| rebase_path(godepfile, "", root_build_dir), |
| "--root-out-dir", |
| rebase_path(root_out_dir, root_build_dir), |
| "--depfile", |
| rebase_path(depfile), |
| "--current-cpu", |
| current_cpu, |
| "--current-os", |
| current_os, |
| "--binname", |
| output_name, |
| "--lib-dir", |
| rebase_path(get_label_info(":any($shlib_toolchain)", "root_out_dir")), |
| "--go-cache", |
| gocache_dir, |
| "--cc", |
| rebase_path("$clang_prefix/clang", "", root_build_dir), |
| "--cxx", |
| rebase_path("$clang_prefix/clang++", "", root_build_dir), |
| "--objcopy", |
| rebase_path("$clang_prefix/llvm-objcopy", "", root_build_dir), |
| "--sysroot", |
| sysroot, |
| "--target", |
| clang_target, |
| ] |
| |
| if (defined(invoker.skip_vet) && !invoker.skip_vet && go_vet_enabled) { |
| args += [ "--vet" ] |
| } |
| |
| # Go build tags |
| tags = [] |
| |
| # Temporarily add a go tag if this GN arg is true. |
| # This is for the FIDL union/xunion migration. |
| if (fidl_write_v1_wireformat) { |
| tags += [ "write_xunion_bytes_for_union" ] |
| } |
| |
| if (defined(invoker.tags)) { |
| tags += invoker.tags |
| } |
| |
| foreach(tag, tags) { |
| args += [ |
| "--tag", |
| tag, |
| ] |
| } |
| if (is_fuzzer) { |
| args += [ |
| "--tag=libfuzzer", |
| "--gcflags=all=-d=libfuzzer", |
| ] |
| } |
| if (carchive) { |
| args += [ "--buildmode=c-archive" ] |
| } |
| |
| if (is_fuchsia) { |
| deps += [ |
| "//third_party/go:go_runtime", |
| "//zircon/public/lib/fdio", |
| ] |
| |
| args += [ |
| # GN provides no way to propagate include paths like this, so, this |
| # is brittle. |
| "--include-dir", |
| rebase_path("//zircon/system/ulib/fdio/include"), |
| "--include-dir", |
| rebase_path("//zircon/third_party/ulib/musl/include"), |
| "--include-dir", |
| rebase_path("//zircon/system/public"), |
| "--go-root", |
| rebase_path("$host_tools_dir/goroot"), |
| ] |
| args += [ |
| # For garnet/go/src/pmd/ramdisk |
| "--include-dir", |
| rebase_path("//zircon/system/ulib/ramdevice-client/include"), |
| "--lib-dir", |
| rebase_path("gen/zircon/public/lib/ramdevice-client", |
| "", |
| root_build_dir), |
| ] |
| |
| foreach(target, zircon_legacy_targets) { |
| if (target.target_name == "zircon") { |
| _libs = target.libs |
| lib = _libs[0] |
| assert(_libs == [ lib ]) |
| _libs = [] |
| args += [ |
| "--lib-dir", |
| rebase_path(get_path_info("$zircon_root_build_dir/$lib", "dir")), |
| ] |
| } |
| } |
| |
| # See //build/config/fuchsia:fdio_config. |
| args += [ |
| "--lib-dir", |
| rebase_path(get_label_info("//build/config/fuchsia:fdio_config", |
| "target_gen_dir")), |
| ] |
| } else { |
| args += [ |
| "--go-root", |
| rebase_path("//prebuilt/third_party/go/${host_platform}"), |
| ] |
| } |
| |
| if (use_strip) { |
| args += [ |
| "--unstripped-binname", |
| rebase_path(unstripped_output_path, root_build_dir), |
| ] |
| } |
| |
| # Add needed arguments for the buildidtool. We should add the stamp file |
| # output by buildidtool to the list of outputs for this action but because |
| # Ninja (and by consequence GN) limits us to one depfile where that depfile |
| # has only one output and we need the depfile for other things we don't |
| # list it as an output. |
| args += [ |
| "--buildidtool", |
| rebase_path("//prebuilt/tools/buildidtool/${host_platform}/buildidtool", |
| root_build_dir), |
| "--build-id-dir", |
| ".build-id", |
| ] |
| |
| if (is_test) { |
| testonly = true |
| args += [ "--is-test=true" ] |
| } |
| |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| args += [ "--go-dep-files" ] |
| foreach(dep, invoker.deps) { |
| gen_dir = get_label_info(dep, "target_gen_dir") |
| name = get_label_info(dep, "name") |
| args += [ rebase_path("$gen_dir/$name.go_deps") ] |
| } |
| } |
| |
| foreach(gopackage, invoker.gopackages) { |
| args += [ |
| "--package", |
| gopackage, |
| ] |
| } |
| |
| metadata = { |
| tool_paths = [] |
| |
| # Record metadata for the //:tool_paths build API for all non-test, |
| # host binaries. |
| if (is_host && !is_test) { |
| tool_paths = [ |
| { |
| cpu = current_cpu |
| label = get_label_info(":$main_target_name", "label_with_toolchain") |
| name = output_name |
| os = current_os |
| path = rebase_path(output_path, root_build_dir) |
| }, |
| ] |
| } |
| |
| binaries = [ |
| { |
| type = "executable" |
| label = get_label_info(":$target_name", "label_with_toolchain") |
| cpu = current_cpu |
| os = current_os |
| if (use_strip) { |
| debug = rebase_path(unstripped_output_path, root_build_dir) |
| } |
| dist = rebase_path(output_path, root_build_dir) |
| if (current_os != "mac" && current_os != "win") { |
| elf_build_id = |
| rebase_path("$output_path.build-id.stamp", root_build_dir) |
| } |
| if (output_breakpad_syms && current_os == "fuchsia") { |
| breakpad = rebase_path("$output_path.sym", root_build_dir) |
| } |
| }, |
| ] |
| } |
| } |
| |
| # Allow host binaries to be published in SDKs. |
| if (define_sdk_target) { |
| file_base = "tools/$output_name" |
| |
| sdk_atom("${target_name}_sdk") { |
| id = "sdk://tools/$output_name" |
| |
| category = invoker.sdk_category |
| |
| meta = { |
| dest = "$file_base-meta.json" |
| schema = "host_tool" |
| value = { |
| type = "host_tool" |
| name = output_name |
| root = "tools" |
| files = [ file_base ] |
| } |
| } |
| |
| files = [ |
| { |
| source = output_path |
| dest = file_base |
| }, |
| ] |
| |
| if (defined(invoker.sdk_deps)) { |
| deps = invoker.sdk_deps |
| } |
| |
| non_sdk_deps = [ ":$main_target_name" ] |
| } |
| } |
| } |
