# Copyright 2020 Google LLC
#
# 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
#
#     https://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.

"""Defines a rule for creating an instrumented fuzzing executable."""

load("@bazel_skylib//lib:dicts.bzl", "dicts")
load("//fuzzing/private:engine.bzl", "FuzzingEngineInfo")
load(
    "//fuzzing/private:instrum_opts.bzl",
    "instrum_defaults",
    "instrum_opts",
)
load(
    "//fuzzing:instrum_opts.bzl",
    "instrum_configs",
    "sanitizer_configs",
)

FuzzingBinaryInfo = provider(
    doc = """
Provider for storing information about a fuzz test binary.
""",
    fields = {
        "binary_file": "The instrumented fuzz test executable.",
        "binary_runfiles": "The runfiles of the fuzz test executable.",
        "corpus_dir": "The directory of the corpus files used as input seeds.",
        "dictionary_file": "The dictionary file to use in fuzzing runs.",
        "engine_info": "The `FuzzingEngineInfo` provider of the fuzzing " +
                       "engine used in the fuzz test.",
        "options_file": "A file containing fuzzing engine and sanitizer " +
                        "options to use during execution. The file loosely " +
                        "follows the INI format and currently only applies " +
                        "to OSS-Fuzz.",
    },
)

def _fuzzing_binary_transition_impl(settings, attr):
    opts = instrum_opts.make(
        copts = settings["//command_line_option:copt"],
        conlyopts = settings["//command_line_option:conlyopt"],
        cxxopts = settings["//command_line_option:cxxopt"],
        linkopts = settings["//command_line_option:linkopt"],
    )

    is_fuzzing_build_mode = settings["@rules_fuzzing//fuzzing:cc_fuzzing_build_mode"]
    if is_fuzzing_build_mode:
        opts = instrum_opts.merge(opts, instrum_defaults.fuzzing_build)

    instrum_config = settings["@rules_fuzzing//fuzzing:cc_engine_instrumentation"]
    if instrum_config in instrum_configs:
        opts = instrum_opts.merge(opts, instrum_configs[instrum_config])
    else:
        fail("unsupported engine instrumentation '%s'" % instrum_config)

    sanitizer_config = settings["@rules_fuzzing//fuzzing:cc_engine_sanitizer"]
    if sanitizer_config in sanitizer_configs:
        opts = instrum_opts.merge(opts, sanitizer_configs[sanitizer_config])
    else:
        fail("unsupported sanitizer '%s'" % sanitizer_config)

    return {
        "//command_line_option:copt": opts.copts,
        "//command_line_option:linkopt": opts.linkopts,
        "//command_line_option:conlyopt": opts.conlyopts,
        "//command_line_option:cxxopt": opts.cxxopts,
        # Make sure binaries are built statically, to maximize the scope of the
        # instrumentation.
        "//command_line_option:dynamic_mode": "off",
    }

fuzzing_binary_transition = transition(
    implementation = _fuzzing_binary_transition_impl,
    inputs = [
        "@rules_fuzzing//fuzzing:cc_engine_instrumentation",
        "@rules_fuzzing//fuzzing:cc_engine_sanitizer",
        "@rules_fuzzing//fuzzing:cc_fuzzing_build_mode",
        "//command_line_option:copt",
        "//command_line_option:conlyopt",
        "//command_line_option:cxxopt",
        "//command_line_option:linkopt",
    ],
    outputs = [
        "//command_line_option:copt",
        "//command_line_option:conlyopt",
        "//command_line_option:cxxopt",
        "//command_line_option:linkopt",
        "//command_line_option:dynamic_mode",
    ],
)

def _fuzzing_binary_impl(ctx):
    output_file = ctx.actions.declare_file(ctx.label.name)
    ctx.actions.symlink(
        output = output_file,
        target_file = ctx.executable.binary,
        is_executable = True,
    )
    if ctx.attr._instrument_binary:
        # The attribute is a list if a transition is attached.
        binary_runfiles = ctx.attr.binary[0][DefaultInfo].default_runfiles
    else:
        binary_runfiles = ctx.attr.binary[DefaultInfo].default_runfiles
    other_runfiles = []
    if ctx.file.corpus:
        other_runfiles.append(ctx.file.corpus)
    if ctx.file.dictionary:
        other_runfiles.append(ctx.file.dictionary)
    if ctx.file.options:
        other_runfiles.append(ctx.file.options)
    return [
        DefaultInfo(
            executable = output_file,
            runfiles = binary_runfiles.merge(ctx.runfiles(files = other_runfiles)),
        ),
        FuzzingBinaryInfo(
            binary_file = ctx.executable.binary,
            binary_runfiles = binary_runfiles,
            corpus_dir = ctx.file.corpus,
            dictionary_file = ctx.file.dictionary,
            engine_info = ctx.attr.engine[FuzzingEngineInfo],
            options_file = ctx.file.options,
        ),
    ]

_common_fuzzing_binary_attrs = {
    "engine": attr.label(
        doc = "The specification of the fuzzing engine used in the binary.",
        providers = [FuzzingEngineInfo],
        mandatory = True,
    ),
    "corpus": attr.label(
        doc = "A directory of corpus files used as input seeds.",
        allow_single_file = True,
    ),
    "dictionary": attr.label(
        doc = "A dictionary file to use in fuzzing runs.",
        allow_single_file = True,
    ),
    "options": attr.label(
        doc = "A file containing fuzzing engine and sanitizer options to use " +
              "use during execution. The file loosely follows the INI " +
              "format and currently only applies to OSS-Fuzz.",
        allow_single_file = True,
    ),
}

fuzzing_binary = rule(
    implementation = _fuzzing_binary_impl,
    doc = """
Creates an instrumented fuzzing executable.

The executable runfiles include the corpus directory and the dictionary file,
if specified.

The instrumentation is controlled by the following flags:

 * `@rules_fuzzing//fuzzing:cc_engine_instrumentation`
 * `@rules_fuzzing//fuzzing:cc_engine_sanitizer`
 * `@rules_fuzzing//fuzzing:cc_fuzzing_build_mode`
""",
    attrs = dicts.add(_common_fuzzing_binary_attrs, {
        "binary": attr.label(
            executable = True,
            doc = "The fuzz test executable to instrument.",
            cfg = fuzzing_binary_transition,
            mandatory = True,
        ),
        "_allowlist_function_transition": attr.label(
            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
        ),
        "_instrument_binary": attr.bool(
            default = True,
        ),
    }),
    executable = True,
    provides = [FuzzingBinaryInfo],
)

fuzzing_binary_uninstrumented = rule(
    implementation = _fuzzing_binary_impl,
    doc = """
Creates an uninstrumented fuzzing executable.

The fuzz test still requires instrumentation to function correctly, so it should
be incorporated in the target configuration (e.g., on the command line or the
.bazelrc configuration file).
""",
    attrs = dicts.add(_common_fuzzing_binary_attrs, {
        "binary": attr.label(
            executable = True,
            doc = "The instrumented fuzz test executable.",
            cfg = "target",
            mandatory = True,
        ),
        "_instrument_binary": attr.bool(
            default = False,
        ),
    }),
    executable = True,
    provides = [FuzzingBinaryInfo],
)