| # Copyright 2020 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/components.gni") |
| import("//build/host.gni") |
| import("//build/testing/test_spec.gni") |
| |
| # TODO(fxbug.dev/48118): Add LSan |
| _cpp_sanitizers = [ |
| "asan", |
| "ubsan", |
| ] |
| |
| # Currently, Go doesn't have any *San specific callbacks beyond those in the dynamic linker. Still, |
| # all of the C/C++ sanitizers should link and run. |
| _go_sanitizers = _cpp_sanitizers |
| |
| _rust_sanitizers = [ "asan" ] |
| |
| # Defines a package of fuzzers |
| # |
| # The `fuzzer_package` template is used to bundle several fuzzers and their associated data into a |
| # single Fuchsia package. See //examples/fuzzers/BUILD.gn for examples. |
| # |
| # Parameters |
| # |
| # package_name (optional) |
| # [string] The name of the package. Defaults to the target name. |
| # |
| # cpp_fuzzers (optional) |
| # go_fuzzers (optional) |
| # rust_fuzzers (optional) |
| # [list] A list of fuzzers for targets in the indicated language. Each list is asscoiated with |
| # the corresponding list of sanitizers, e.g. each label in `cpp_fuzzers` is built as a fuzzer |
| # when the toolchain variant selected for that label matches an element of `_cpp_sanitizers`. |
| # |
| # Each element of `fuzzers` is either a label or a scope. Label elements act as "shortcuts" |
| # that use default values for each field in a scope element. The scope elements can include |
| # the following fields: |
| # |
| # label (required) |
| # [label] The fuzzer() target to include. |
| # |
| # name (optional) |
| # output_name (optional) |
| # [string] Same as for fuzzer(), and should match the value(s) for the associated `label`. |
| # For label elements, these are both set to simple name of the label. |
| # |
| # sanitizers (optional) |
| # [list of strings] Overrides the default, per-language sanitizers. This should be omitted |
| # unless necessary. |
| # |
| # fuzz_host (optional) |
| # [boolean] Indicates whether to also build fuzzer binaries on host. Defaults to false. |
| # |
| # host_only (optional) |
| # [boolean] Indicates whether to omit this fuzzer from the Fuchsia fuzzers package. |
| # Implies `fuzz_host`. Defaults to false. |
| # |
| # visibility (optional) |
| # [list] Usual meaning. |
| # |
| # TODO(fxbug.dev/60168): Deprecated parameters. These will be removed when consumers have updated. |
| # |
| # fuzzers (optional) |
| # [list] Same as `cpp_fuzzers`. |
| # |
| # fuzz_host (optional) |
| # [boolean] Sets `fuzz_host` for all fuzzer scopes, unless overridden. |
| # |
| # host_only (optional) |
| # [boolean] Sets `host_only` for all fuzzer scopes, unless overridden. |
| # |
| template("fuzzer_package") { |
| # This target will create a group with up to three parts: a package of fuzzers and/or fuzzer |
| # tests, a set of host fuzzers treated as host tools, and a group of host fuzzer tests. Which |
| # fuzzers are included in each part depends of the associated fuzzer profile and current |
| # toolchain variant. |
| group_deps = [] |
| |
| # Step 1: Gather up lists of fuzzers by language, and associated them with that language's |
| # sanitizers. |
| by_language = [] |
| invoker_fuzz_host = defined(invoker.fuzz_host) && invoker.fuzz_host |
| invoker_host_only = defined(invoker.host_only) && invoker.host_only |
| |
| # TODO(fxbug.dev/60168): Update consumers to use `cpp_fuzzers`, then drop `fuzzers`. |
| if (defined(invoker.fuzzers)) { |
| by_language += [ |
| { |
| fuzzers = invoker.fuzzers |
| fuzz_host = invoker_fuzz_host |
| host_only = invoker_host_only |
| sanitizers = _cpp_sanitizers |
| }, |
| ] |
| } |
| if (defined(invoker.cpp_fuzzers)) { |
| by_language += [ |
| { |
| fuzzers = invoker.cpp_fuzzers |
| fuzz_host = invoker_fuzz_host |
| host_only = invoker_host_only |
| sanitizers = _cpp_sanitizers |
| }, |
| ] |
| } |
| if (defined(invoker.go_fuzzers)) { |
| not_needed([ |
| "invoker_fuzz_host", |
| "invoker_host_only", |
| ]) |
| by_language += [ |
| { |
| fuzzers = invoker.go_fuzzers |
| |
| # TODO(fxbug.dev/44551): go host fuzzers fail to link on mac-x64 |
| fuzz_host = false |
| host_only = false |
| sanitizers = _go_sanitizers |
| }, |
| ] |
| } |
| if (defined(invoker.rust_fuzzers)) { |
| not_needed([ |
| "invoker_fuzz_host", |
| "invoker_host_only", |
| ]) |
| by_language += [ |
| { |
| fuzzers = invoker.rust_fuzzers |
| |
| # TODO(fxbug.dev/48624): rustc segfaults when building hostlibs. |
| fuzz_host = false |
| host_only = false |
| sanitizers = _rust_sanitizers |
| }, |
| ] |
| } |
| assert(by_language != [], "no fuzzers specified") |
| |
| # Step 2: "Normalize" the fuzzers by making each one into a scope with the same fields. |
| normalized = [] |
| foreach(language, by_language) { |
| foreach(fuzzer, language.fuzzers) { |
| if (fuzzer == "$fuzzer") { |
| fuzzer = { |
| label = fuzzer |
| } |
| } else { |
| assert(defined(fuzzer.label), "missing fuzzer label") |
| } |
| normalized += [ |
| { |
| # Convert labels to scopes, if needed |
| label = get_label_info(fuzzer.label, "label_no_toolchain") |
| |
| # Get the name early in order to set the default `output_name`. |
| if (defined(fuzzer.name)) { |
| name = fuzzer.name |
| } else { |
| name = get_label_info(label, "name") |
| } |
| dir = get_label_info(label, "dir") |
| |
| # Set defaults |
| output_name = name |
| forward_variables_from(language, "*", [ "fuzzers" ]) |
| |
| # Allow overrides |
| forward_variables_from(fuzzer, |
| "*", |
| [ |
| "label", |
| "name", |
| ]) |
| }, |
| ] |
| } |
| } |
| |
| # Step 3: Assign each fuzzer to one or more of the following by matching the fuzzer scope against |
| # the currently selected toolchain variants: |
| # - A fuzzers package, either as binaries or unit tests |
| # - A set of host fuzzer tools |
| # - A set of host unit tests for the host fuzzer tools |
| fuzzed = [] |
| tested = [] |
| host_fuzzed = [] |
| host_tested = [] |
| foreach(fuzzer, normalized) { |
| fuzz = false |
| |
| # Compare each selected variant with a profile's supported sanitizers. Unselected fuzzers are |
| # built as uninstrumented unit tests instead; see `test("${fuzzer_name}_test")` above. |
| # |
| # IMPORTANT: Keep this in sync with the selection mechanism implemented in the variant_target() |
| # template defined in //build/config/BUILDCONFIG.gn |
| fuzz = false |
| foreach(selector, select_variant_canonical) { |
| if (!fuzz) { |
| foreach(sanitizer, fuzzer.sanitizers) { |
| if (!fuzz && selector.variant == "${sanitizer}-fuzzer") { |
| if (!fuzz && defined(selector.target_type)) { |
| foreach(candidate, selector.target_type) { |
| if (candidate == "fuzzed_executable") { |
| fuzz = true |
| } |
| } |
| } |
| |
| if (!fuzz && defined(selector.output_name)) { |
| foreach(candidate, selector.output_name) { |
| if (candidate == fuzzer.output_name) { |
| fuzz = true |
| } |
| } |
| } |
| |
| if (!fuzz && defined(selector.label)) { |
| foreach(candidate, selector.label) { |
| if (candidate == fuzzer.label) { |
| fuzz = true |
| } |
| } |
| } |
| |
| if (!fuzz && defined(selector.name)) { |
| foreach(candidate, selector.name) { |
| if (candidate == fuzzer.name) { |
| fuzz = true |
| } |
| } |
| } |
| |
| if (!fuzz && defined(selector.dir)) { |
| foreach(candidate, selector.dir) { |
| if (candidate == fuzzer.dir) { |
| fuzz = true |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| # Add the fuzzers and tests from this profile to the aggregated lists. |
| if (!fuzzer.host_only) { |
| if (fuzz) { |
| fuzzed += [ fuzzer ] |
| } else { |
| tested += [ fuzzer ] |
| } |
| } |
| if (fuzzer.fuzz_host || fuzzer.host_only) { |
| if (fuzz) { |
| host_fuzzed += [ fuzzer ] |
| } else { |
| host_tested += [ fuzzer ] |
| } |
| } |
| } |
| |
| # Step 4: Assemble a Fuchsia package of fuzzers and/or unit tests. Many of the package parameter |
| # values need to match the '*_target' and '*_output' values in the `fuzzer` template above. |
| # Ideally this would use `get_target_outputs` to only need the former, but fuzzers and packages |
| # are not required to be defined in the same GN file. |
| |
| # TODO(fxbug.dev/60168): Update consumers, then drop this automatic conversion. |
| if (fuzzed != [] || tested != []) { |
| if (defined(invoker.package_name)) { |
| _package_name = string_replace(invoker.package_name, "_", "-") |
| } else { |
| _package_name = string_replace(invoker.target_name, "_", "-") |
| } |
| _package_url = "fuchsia-pkg://fuchsia.com/$_package_name" |
| package_target_name = target_name + "-pkg" |
| |
| test_deps = [] |
| foreach(fuzzer, tested) { |
| test_spec_target = "${target_name}_${fuzzer.name}_test_spec" |
| test_spec(test_spec_target) { |
| target = get_label_info(fuzzer.label, "label_with_toolchain") |
| build_rule = "fuzzer_package" |
| package_url = "$_package_url#meta/${fuzzer.output_name}_test.cm" |
| package_label = |
| get_label_info(":${invoker.target_name}", "label_with_toolchain") |
| package_manifests = [ rebase_path( |
| "$target_out_dir/$package_target_name/package_manifest.json", |
| root_build_dir) ] |
| if (is_fuchsia) { |
| # Fuzzer tests may produce errors so long as they do not crash. |
| log_settings = { |
| max_severity = "ERROR" |
| } |
| } |
| } |
| test_deps += [ ":$test_spec_target" ] |
| } |
| |
| # The component names in this section MUST match those in `fuzzer`. |
| fuchsia_package(package_target_name) { |
| testonly = true |
| visibility = [ ":*" ] |
| package_name = _package_name |
| deps = test_deps |
| foreach(fuzzer, tested) { |
| deps += [ "${fuzzer.label}_test_component" ] |
| } |
| foreach(fuzzer, fuzzed) { |
| deps += [ "${fuzzer.label}_component" ] |
| } |
| } |
| group_deps += [ ":$package_target_name" ] |
| } |
| |
| # Step 5: Treat host fuzzers as tools. If we get to the point of having name collisions, we'll |
| # need to extend `install_host_tools` to allow copying to specific subdirectories of |
| # `host_tools_dir`. |
| if (host_fuzzed != []) { |
| host_fuzzers_target_name = target_name + "_host" |
| install_host_tools(host_fuzzers_target_name) { |
| testonly = true |
| visibility = [ ":*" ] |
| deps = [] |
| outputs = [] |
| foreach(fuzzer, host_fuzzed) { |
| deps += [ "${fuzzer.label}_executable" ] |
| outputs += [ fuzzer.output_name ] |
| } |
| } |
| group_deps += [ ":$host_fuzzers_target_name" ] |
| } |
| |
| # Step 6: For host fuzzer tests, ensure the deps build with the correct toolchain. |
| if (host_tested != []) { |
| host_tests_target_name = target_name + "_host_tests" |
| group(host_tests_target_name) { |
| testonly = true |
| visibility = [ ":*" ] |
| deps = [] |
| foreach(fuzzer, host_tested) { |
| deps += [ "${fuzzer.label}_test_executable($host_toolchain)" ] |
| } |
| } |
| group_deps += [ ":$host_tests_target_name" ] |
| } |
| |
| # Step 7: Include everything in the group |
| group(target_name) { |
| testonly = true |
| forward_variables_from(invoker, [ "visibility" ]) |
| deps = group_deps |
| |
| # This metadata will be used to generate out/default/fuzzers.json |
| metadata = { |
| if (defined(invoker.metadata)) { |
| forward_variables_from(invoker.metadata, "*", [ "fuzz_spec" ]) |
| } |
| fuzz_spec = [] |
| foreach(fuzzer, fuzzed + tested) { |
| fuzz_spec += [ |
| { |
| label = fuzzer.label |
| package = _package_name |
| package_url = _package_url |
| }, |
| ] |
| } |
| } |
| } |
| } |
| |
| # TODO(fxbug.dev/60168): Update consumers to use `fuzzer_package` instead. |
| template("fuzzers_package") { |
| fuzzer_package(target_name) { |
| forward_variables_from(invoker, "*") |
| } |
| } |
