| # 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, "*") | |
| } | |
| } |