# Copyright 2023 The MediaPipe Authors. All rights reserved.
#
# 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
#
#    http://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.

"""Bazel build rules for Halide."""

load("@bazel_skylib//lib:collections.bzl", "collections")
load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "use_cpp_toolchain")

def halide_language_copts():
    _common_opts = [
        "-fPIC",
        "-frtti",
        "-Wno-conversion",
        "-Wno-sign-compare",
    ]
    _posix_opts = [
        "$(STACK_FRAME_UNLIMITED)",
        "-fno-exceptions",
        "-funwind-tables",
        "-fvisibility-inlines-hidden",
    ]
    _msvc_opts = [
        "-D_CRT_SECURE_NO_WARNINGS",
        "/MD",
    ]
    return _common_opts + select({
        "//conditions:default": _posix_opts,
        "@mediapipe//mediapipe:windows": _msvc_opts,
    })

def halide_language_linkopts():
    _linux_opts = [
        "-ldl",
        "-lpthread",
        "-lz",
        "-rdynamic",
    ]
    _osx_opts = [
        "-lz",
        "-Wl,-stack_size",
        "-Wl,1000000",
    ]
    _msvc_opts = []
    return select({
        "//conditions:default": _linux_opts,
        "@mediapipe//mediapipe:macos": _osx_opts,
        "@mediapipe//mediapipe:windows": _msvc_opts,
    })

def halide_runtime_linkopts():
    """ Return the linkopts needed when linking against halide_library_runtime.

    Returns:
        List to be used for linkopts.
    """
    _posix_opts = [
        "-ldl",
        "-lpthread",
    ]
    _android_opts = [
        "-llog",
    ]
    _msvc_opts = []

    return select({
        "//conditions:default": _posix_opts,
        "@mediapipe//mediapipe:android": _android_opts,
        "@mediapipe//mediapipe:windows": _msvc_opts,
    })

# Map of halide-target-base -> config_settings
_HALIDE_TARGET_CONFIG_SETTINGS_MAP = {
    # Android
    "arm-32-android": ["@halide//:halide_config_android_arm"],
    "arm-64-android": ["@halide//:halide_config_android_arm64"],
    "x86-32-android": ["@halide//:halide_config_android_x86_32"],
    "x86-64-android": ["@halide//:halide_config_android_x86_64"],
    # iOS
    "arm-32-ios": ["@halide//:halide_config_ios_arm"],
    "arm-64-ios": ["@halide//:halide_config_ios_arm64"],
    # OSX (or iOS simulator)
    "x86-32-osx": ["@halide//:halide_config_macos_x86_32", "@halide//:halide_config_ios_x86_32"],
    "x86-64-osx": ["@halide//:halide_config_macos_x86_64", "@halide//:halide_config_ios_x86_64"],
    "arm-64-osx": ["@halide//:halide_config_macos_arm64"],
    # Windows
    "x86-64-windows": ["@halide//:halide_config_windows_x86_64"],
    # Linux
    "x86-64-linux": ["@halide//:halide_config_linux_x86_64"],
    # deliberately nothing here using //conditions:default
}

_HALIDE_TARGET_MAP_DEFAULT = {
    "x86-64-linux": [
        "x86-64-linux-sse41-avx-avx2-fma",
        "x86-64-linux-sse41",
        "x86-64-linux",
    ],
    "x86-64-osx": [
        "x86-64-osx-sse41-avx-avx2-fma",
        "x86-64-osx-sse41",
        "x86-64-osx",
    ],
    "x86-64-windows": [
        "x86-64-windows-sse41-avx-avx2-fma",
        "x86-64-windows-sse41",
        "x86-64-windows",
    ],
}

def halide_library_default_target_map():
    return _HALIDE_TARGET_MAP_DEFAULT

# Alphabetizes the features part of the target to make sure they always match no
# matter the concatenation order of the target string pieces.
def _canonicalize_target(halide_target):
    if halide_target == "host":
        return halide_target
    if "," in halide_target:
        fail("Multitarget may not be specified here")
    tokens = halide_target.split("-")
    if len(tokens) < 3:
        fail("Illegal target: %s" % halide_target)

    # rejoin the tokens with the features sorted
    return "-".join(tokens[0:3] + sorted(tokens[3:]))

# Converts comma and dash separators to underscore and alphabetizes
# the features part of the target to make sure they always match no
# matter the concatenation order of the target string pieces.
def _halide_target_to_bazel_rule_name(multitarget):
    subtargets = multitarget.split(",")
    subtargets = [_canonicalize_target(st).replace("-", "_") for st in subtargets]
    return "_".join(subtargets)

# The second argument is True if there is a separate file generated
# for each subtarget of a multitarget output, False if not. The third
# argument is True if the output is a directory (vs. a single file).
# The fourth argument is a list of output group(s) that the files should
# be added to.

_is_multi = True
_is_single = False
_is_file = False

_output_extensions = {
    "assembly": ("s", _is_multi, _is_file, []),
    "bitcode": ("bc", _is_multi, _is_file, ["generated_bitcode"]),
    "c_header": ("h", _is_single, _is_file, ["generated_headers"]),
    "c_source": ("halide_generated.cpp", _is_multi, _is_file, []),
    "compiler_log": ("halide_compiler_log", _is_single, _is_file, ["generated_object", "generated_compiler_log"]),
    "cpp_stub": ("stub.h", _is_single, _is_file, []),
    "featurization": ("featurization", _is_multi, _is_file, []),
    "llvm_assembly": ("ll", _is_multi, _is_file, []),
    "object": ("o", _is_single, _is_file, ["generated_object"]),
    "python_extension": ("py.cpp", _is_single, _is_file, []),
    "registration": ("registration.cpp", _is_single, _is_file, ["generated_registration"]),
    "schedule": ("schedule.h", _is_single, _is_file, []),
    "static_library": ("a", _is_single, _is_file, ["generated_object"]),
    "stmt": ("stmt", _is_multi, _is_file, []),
    "stmt_html": ("stmt.html", _is_multi, _is_file, []),
}

def _add_output_file(f, fmt, output_files, output_dict, verbose_extra_outputs, verbose_output_paths):
    if fmt in verbose_extra_outputs:
        verbose_output_paths.append(f.path)
    output_files.append(f)
    if fmt in _output_extensions:
        for group in _output_extensions[fmt][3]:
            output_dict.setdefault(group, []).append(f)

HalideFunctionNameInfo = provider(fields = ["function_name"])
HalideGeneratorBinaryInfo = provider(fields = ["generator_binary"])
HalideGeneratorNameInfo = provider(fields = ["generator_name_"])
HalideGeneratorParamsInfo = provider(fields = ["generator_params"])
HalideLibraryNameInfo = provider(fields = ["library_name"])
HalideTargetFeaturesInfo = provider(fields = ["target_features"])

def _gengen_closure_impl(ctx):
    return [
        HalideGeneratorBinaryInfo(generator_binary = ctx.attr.generator_binary),
        HalideGeneratorNameInfo(generator_name_ = ctx.attr.generator_name_),
    ]

_gengen_closure = rule(
    implementation = _gengen_closure_impl,
    attrs = {
        "generator_binary": attr.label(
            executable = True,
            allow_files = True,
            mandatory = True,
            cfg = "exec",
        ),
        # "generator_name" is apparently reserved by Bazel for attrs in rules
        "generator_name_": attr.string(mandatory = True),
    },
    provides = [HalideGeneratorBinaryInfo, HalideGeneratorNameInfo],
)

def _halide_library_instance_impl(ctx):
    generator_binary = ctx.attr.generator_closure[HalideGeneratorBinaryInfo].generator_binary if ctx.attr.generator_closure else ""
    generator_name = ctx.attr.generator_closure[HalideGeneratorNameInfo].generator_name_ if ctx.attr.generator_closure else ""
    return [
        HalideFunctionNameInfo(function_name = ctx.attr.function_name),
        HalideGeneratorBinaryInfo(generator_binary = generator_binary),
        HalideGeneratorNameInfo(generator_name_ = generator_name),
        HalideGeneratorParamsInfo(generator_params = ctx.attr.generator_params),
        HalideLibraryNameInfo(library_name = ctx.attr.library_name),
        HalideTargetFeaturesInfo(target_features = ctx.attr.target_features),
    ]

_halide_library_instance = rule(
    implementation = _halide_library_instance_impl,
    attrs = {
        "function_name": attr.string(),
        "generator_closure": attr.label(
            cfg = "exec",
            providers = [HalideGeneratorBinaryInfo, HalideGeneratorNameInfo],
        ),
        "generator_params": attr.string_list(),
        "library_name": attr.string(),
        "target_features": attr.string_list(),
    },
    provides = [
        HalideFunctionNameInfo,
        HalideGeneratorBinaryInfo,
        HalideGeneratorNameInfo,
        HalideGeneratorParamsInfo,
        HalideLibraryNameInfo,
        HalideTargetFeaturesInfo,
    ],
)

def _gengen_impl(ctx):
    if _has_dupes(ctx.attr.requested_outputs):
        fail("Duplicate values in outputs: " + str(ctx.attr.requested_outputs))

    function_name = ctx.attr.function_name[HalideFunctionNameInfo].function_name if ctx.attr.function_name else ""
    generator_binary = ctx.attr.generator_binary[HalideGeneratorBinaryInfo].generator_binary if ctx.attr.generator_binary else ""
    generator_name_ = ctx.attr.generator_name_[HalideGeneratorNameInfo].generator_name_ if ctx.attr.generator_name_ else ""
    generator_params = ctx.attr.generator_params[HalideGeneratorParamsInfo].generator_params if ctx.attr.generator_params else []
    library_name = ctx.attr.library_name[HalideLibraryNameInfo].library_name if ctx.attr.library_name else ""
    target_features = ctx.attr.target_features[HalideTargetFeaturesInfo].target_features if ctx.attr.target_features else []

    for gp in generator_params:
        if " " in gp:
            fail("%s: Entries in generator_params must not contain spaces." % library_name)

    # Escape backslashes and double quotes.
    generator_params = [gp.replace("\\", '\\\\"').replace('"', '\\"') for gp in generator_params]

    execution_requirements = {}

    # --- Calculate the output type(s) we're going to produce (and which ones should be verbose)
    quiet_extra_outputs = []
    verbose_extra_outputs = []
    if ctx.attr.consider_halide_extra_outputs:
        if "halide_extra_outputs" in ctx.var:
            verbose_extra_outputs = ctx.var.get("halide_extra_outputs", "").split(",")
        if "halide_extra_outputs_quiet" in ctx.var:
            quiet_extra_outputs = ctx.var.get("halide_extra_outputs_quiet", "").split(",")
    requested_outputs = sorted(collections.uniq(ctx.attr.requested_outputs +
                                                verbose_extra_outputs +
                                                quiet_extra_outputs))

    # --- Assemble halide_target, adding extra features if necessary
    base_target = ctx.attr.halide_base_target
    if "," in base_target:
        fail("halide_base_target should never be a multitarget")
    if len(base_target.split("-")) != 3:
        fail("halide_base_target should have exactly 3 components")

    target_features = target_features + ctx.var.get("halide_target_features", "").split(",")

    if "no_runtime" in target_features:
        fail("Specifying 'no_runtime' in halide_target_features is not supported; " +
             "please add 'add_halide_runtime_deps = False' to the halide_library() rule instead.")

    for san in ["asan", "msan", "tsan"]:
        if san in target_features:
            fail("halide_library doesn't support '%s' in halide_target_features; please build with --config=%s instead." % (san, san))

    # Append the features common to everything.
    target_features.append("c_plus_plus_name_mangling")
    target_features.append("no_runtime")

    # Make it all neat and tidy.
    target_features = sorted(collections.uniq(target_features))

    # Get the multitarget list (if any) from halide_target_map
    halide_targets = ctx.attr.halide_target_map.get(base_target, [base_target])

    # Add the extra features to all of them
    halide_targets = _add_features_to_all(halide_targets, target_features)

    leaf_name = ctx.attr.filename.split("/")[-1]

    output_files = []
    output_dict = {}
    verbose_output_paths = []
    inputs = []

    env = {
        "HL_DEBUG_CODEGEN": str(ctx.var.get("halide_debug_codegen", 0)),
        # --define halide_llvm_args=-time-passes is a typical usage
        "HL_LLVM_ARGS": str(ctx.var.get("halide_llvm_args", "")),
    }

    be_very_quiet = ctx.var.get("halide_experimental_quiet", False)  # I'm hunting wabbit...

    # --- Calculate the final set of output files
    for fmt in requested_outputs:
        if fmt not in _output_extensions:
            fail("Unknown Halide output '%s'; known outputs are %s" %
                 (fmt, sorted(_output_extensions.keys())))
        ext, is_multiple, is_dir, _ = _output_extensions[fmt]

        # Special-case Windows file extensions
        if "windows" in halide_targets[-1]:
            if ext == "o":
                ext = "obj"
            if ext == "a":
                ext = "lib"
        if is_multiple and len(halide_targets) > 1:
            for h in halide_targets:
                suffix = _canonicalize_target(h)
                name = "%s-%s.%s" % (ctx.attr.filename, suffix, ext)
                f = ctx.actions.declare_directory(name) if is_dir else ctx.actions.declare_file(name)
                _add_output_file(f, fmt, output_files, output_dict, verbose_extra_outputs, verbose_output_paths)
        else:
            name = "%s.%s" % (ctx.attr.filename, ext)
            f = ctx.actions.declare_directory(name) if is_dir else ctx.actions.declare_file(name)
            _add_output_file(f, fmt, output_files, output_dict, verbose_extra_outputs, verbose_output_paths)

    # --- Progress message(s), including log info about any 'extra' files being output due to --define halide_extra_output
    progress_message = "Executing generator %s with target (%s) args (%s)." % (
        generator_name_,
        ",".join(halide_targets),
        " ".join(generator_params),
    )

    for f in output_files:
        if any([f.path.endswith(suf) for suf in [".h", ".a", ".o", ".lib", ".registration.cpp", ".bc", ".halide_compiler_log"]]):
            continue

        # If an extra output was specified via --define halide_extra_outputs=foo on the command line,
        # add to the progress message (so that it is ephemeral and doesn't clog stdout).
        #
        # (Trailing space is intentional since Starlark will append a period to the end,
        # making copy-n-paste harder than it might otherwise be...)
        if not be_very_quiet:
            extra_msg = "Emitting extra Halide output: %s " % f.path
            progress_message += "\n" + extra_msg
            if f.path in verbose_output_paths:
                # buildifier: disable=print
                print(extra_msg)

    # --- Construct the arguments list for the Generator
    arguments = ctx.actions.args()
    arguments.add("-o", output_files[0].dirname)
    if ctx.attr.generate_runtime:
        arguments.add("-r", leaf_name)
        if len(halide_targets) > 1:
            fail("Only one halide_target allowed when using generate_runtime")
        if function_name:
            fail("halide_function_name not allowed when using generate_runtime")
    else:
        arguments.add("-g", generator_name_)
        arguments.add("-n", leaf_name)
        if function_name:
            arguments.add("-f", function_name)

    if requested_outputs:
        arguments.add_joined("-e", requested_outputs, join_with = ",")

    # Can't use add_joined(), as it will insert a space after target=
    arguments.add("target=%s" % (",".join(halide_targets)))
    if generator_params:
        for p in generator_params:
            for s in ["target"]:
                if p.startswith("%s=" % s):
                    fail("You cannot specify %s in the generator_params parameter in bazel." % s)
        arguments.add_all(generator_params)

    show_gen_arg = ctx.var.get("halide_show_generator_command", "")

    # If it's an exact match of a fully qualified path, show just that one.
    # If it's * or "all", match everything.
    if library_name and show_gen_arg in [library_name, "all", "*"] and not ctx.attr.generate_runtime:
        # The 'Args' object can be printed, but can't be usefully converted to a string, or iterated,
        # so we'll reproduce the logic here. We'll also take the opportunity to add or augment
        # some args to be more useful to whoever runs it (eg, add `-v=1`, add some output files).
        sg_args = ["-v", "1"]
        sg_args += ["-o", "/tmp"]
        sg_args += ["-g", generator_name_]
        sg_args += ["-n", leaf_name]
        if function_name:
            sg_args += ["-f", function_name]
        if requested_outputs:
            # Ensure that several commonly-useful output are added
            ro = sorted(collections.uniq(requested_outputs + ["stmt", "assembly", "llvm_assembly"]))
            sg_args += ["-e", ",".join(ro)]
        sg_args.append("target=%s" % (",".join(halide_targets)))

        if generator_params:
            sg_args += generator_params

        # buildifier: disable=print
        print(
            "\n\nTo locally run the Generator for",
            library_name,
            "use the command:\n\n",
            "bazel run -c opt",
            generator_binary.label,
            "--",
            " ".join(sg_args),
            "\n\n",
        )

    # Finally... run the Generator.
    ctx.actions.run(
        execution_requirements = execution_requirements,
        arguments = [arguments],
        env = env,
        executable = generator_binary.files_to_run.executable,
        mnemonic = "ExecuteHalideGenerator",
        inputs = depset(direct = inputs),
        outputs = output_files,
        progress_message = progress_message,
        exec_group = "generator",
    )

    return [
        DefaultInfo(files = depset(direct = output_files)),
        OutputGroupInfo(**output_dict),
    ]

_gengen = rule(
    implementation = _gengen_impl,
    attrs = {
        "consider_halide_extra_outputs": attr.bool(),
        "filename": attr.string(),
        "generate_runtime": attr.bool(default = False),
        "generator_binary": attr.label(
            cfg = "exec",
            providers = [HalideGeneratorBinaryInfo],
        ),
        # "generator_name" is apparently reserved by Bazel for attrs in rules
        "generator_name_": attr.label(
            cfg = "exec",
            providers = [HalideGeneratorNameInfo],
        ),
        "halide_base_target": attr.string(),
        "function_name": attr.label(
            cfg = "target",
            providers = [
                HalideFunctionNameInfo,
            ],
        ),
        "generator_params": attr.label(
            cfg = "target",
            providers = [
                HalideGeneratorParamsInfo,
            ],
        ),
        "library_name": attr.label(
            cfg = "target",
            providers = [
                HalideLibraryNameInfo,
            ],
        ),
        "target_features": attr.label(
            cfg = "target",
            providers = [
                HalideTargetFeaturesInfo,
            ],
        ),
        "halide_target_map": attr.string_list_dict(),
        "requested_outputs": attr.string_list(),
        "_cc_toolchain": attr.label(default = "@bazel_tools//tools/cpp:current_cc_toolchain"),
    },
    fragments = ["cpp"],
    output_to_genfiles = True,
    toolchains = use_cpp_toolchain(),
    exec_groups = {
        "generator": exec_group(),
    },
)

def _add_target_features(target, features):
    if "," in target:
        fail("Cannot use multitarget here")
    new_target = target.split("-")
    for f in features:
        if f and f not in new_target:
            new_target.append(f)
    return "-".join(new_target)

def _add_features_to_all(halide_targets, features):
    return [_canonicalize_target(_add_target_features(t, features)) for t in halide_targets]

def _has_dupes(some_list):
    clean = collections.uniq(some_list)
    return sorted(some_list) != sorted(clean)

# Target features which do not affect runtime compatibility.
_IRRELEVANT_FEATURES = collections.uniq([
    "arm_dot_prod",
    "arm_fp16",
    "c_plus_plus_name_mangling",
    "check_unsafe_promises",
    "embed_bitcode",
    "enable_llvm_loop_opt",
    "large_buffers",
    "no_asserts",
    "no_bounds_query",
    "profile",
    "strict_float",
    "sve",
    "sve2",
    "trace_loads",
    "trace_pipeline",
    "trace_realizations",
    "trace_stores",
    "user_context",
    "wasm_sat_float_to_int",
    "wasm_signext",
    "wasm_simd128",
])

def _discard_irrelevant_features(halide_target_features = []):
    return sorted(collections.uniq([f for f in halide_target_features if f not in _IRRELEVANT_FEATURES]))

def _halide_library_runtime_target_name(halide_target_features = []):
    return "_".join(["halide_library_runtime"] + _discard_irrelevant_features(halide_target_features))

def _define_halide_library_runtime(
        halide_target_features = [],
        compatible_with = []):
    target_name = _halide_library_runtime_target_name(halide_target_features)

    if not native.existing_rule("halide_library_runtime.generator"):
        halide_generator(
            name = "halide_library_runtime.generator",
            srcs = [],
            deps = [],
            visibility = ["//visibility:private"],
        )
    condition_deps = {}
    for base_target, cfgs in _HALIDE_TARGET_CONFIG_SETTINGS_MAP.items():
        target_features = _discard_irrelevant_features(halide_target_features)
        halide_target_name = _halide_target_to_bazel_rule_name(base_target)
        gengen_name = "%s_%s" % (halide_target_name, target_name)

        _halide_library_instance(
            name = "%s.library_instance" % gengen_name,
            compatible_with = compatible_with,
            function_name = "",
            generator_closure = ":halide_library_runtime.generator_closure",
            generator_params = [],
            library_name = "",
            target_features = target_features,
            visibility = ["//visibility:private"],
        )
        hl_instance = ":%s.library_instance" % gengen_name

        _gengen(
            name = gengen_name,
            compatible_with = compatible_with,
            filename = "%s/%s" % (halide_target_name, target_name),
            generate_runtime = True,
            generator_binary = hl_instance,
            generator_name_ = hl_instance,
            halide_base_target = base_target,
            requested_outputs = ["object"],
            tags = ["manual"],
            target_features = hl_instance,
            visibility = ["@halide//:__subpackages__"],
        )
        for cfg in cfgs:
            condition_deps[cfg] = [":%s" % gengen_name]

    deps = []
    native.cc_library(
        name = target_name,
        compatible_with = compatible_with,
        srcs = select(condition_deps),
        linkopts = halide_runtime_linkopts(),
        tags = ["manual"],
        deps = deps,
        visibility = ["//visibility:public"],
    )

    return target_name

def _standard_library_runtime_features():
    _standard_features = [
        [],
        ["cuda"],
        ["metal"],
        ["opencl"],
        ["openglcompute"],
        ["openglcompute", "egl"],
    ]
    return [f for f in _standard_features] + [f + ["debug"] for f in _standard_features]

def _standard_library_runtime_names():
    return collections.uniq([_halide_library_runtime_target_name(f) for f in _standard_library_runtime_features()])

def halide_library_runtimes(compatible_with = []):
    # Note that we don't use all of these combinations
    # (and some are invalid), but that's ok.
    for cpu in ["arm", "arm64", "x86_32", "x86_64"]:
        for os in ["android", "linux", "windows", "ios", "macos"]:
            native.config_setting(
                name = "halide_config_%s_%s" % (os, cpu),
                constraint_values = [
                    "@platforms//os:%s" % os,
                    "@platforms//cpu:%s" % cpu,
                ],
                visibility = ["//visibility:public"],
            )

    unused = [
        _define_halide_library_runtime(f, compatible_with = compatible_with)
        for f in _standard_library_runtime_features()
    ]
    unused = unused  # unused variable

def halide_generator(
        name,
        srcs,
        compatible_with = [],
        copts = [],
        deps = [],
        generator_name = "",
        includes = [],
        tags = [],
        testonly = False,
        visibility = None):
    if not name.endswith(".generator"):
        fail("halide_generator rules must end in .generator")

    basename = name[:-10]  # strip ".generator" suffix
    if not generator_name:
        generator_name = basename

    # Note: This target is public, but should not be needed by the vast
    # majority of users. Unless you are writing a custom Bazel rule that
    # involves Halide generation, you most probably won't need to depend on
    # this rule.
    native.cc_binary(
        name = name,
        copts = copts + halide_language_copts(),
        linkopts = halide_language_linkopts(),
        compatible_with = compatible_with,
        srcs = srcs,
        deps = [
            "@halide//:gengen",
            "@halide//:language",
        ] + deps,
        tags = ["manual"] + tags,
        testonly = testonly,
        visibility = ["//visibility:public"],
    )

    _gengen_closure(
        name = "%s_closure" % name,
        generator_binary = name,
        generator_name_ = generator_name,
        compatible_with = compatible_with,
        testonly = testonly,
        visibility = ["//visibility:private"],
    )

# This rule exists to allow us to select() on halide_target_features.
def _select_halide_library_runtime_impl(ctx):
    f = ctx.attr.halide_target_features

    standard_runtimes = {t.label.name: t for t in ctx.attr._standard_runtimes}

    f = sorted(_discard_irrelevant_features(collections.uniq(f)))
    runtime_name = _halide_library_runtime_target_name(f)
    if runtime_name not in standard_runtimes:
        fail(("There is no Halide runtime available for the feature set combination %s. " +
              "Please use contact information from halide-lang.org to contact the Halide " +
              "team to add the right combination.") % str(f))

    return standard_runtimes[runtime_name][CcInfo]

_select_halide_library_runtime = rule(
    implementation = _select_halide_library_runtime_impl,
    attrs = {
        "halide_target_features": attr.string_list(),
        "_standard_runtimes": attr.label_list(
            default = ["@halide//:%s" % n for n in _standard_library_runtime_names()],
            providers = [CcInfo],
        ),
    },
    provides = [CcInfo],
)

def halide_library_from_generator(
        name,
        generator,
        add_halide_runtime_deps = True,
        compatible_with = [],
        deps = [],
        function_name = None,
        generator_params = [],
        halide_target_features = [],
        halide_target_map = halide_library_default_target_map(),
        includes = [],
        namespace = None,
        tags = [],
        testonly = False,
        visibility = None):
    if not function_name:
        function_name = name

    if namespace:
        function_name = "%s::%s" % (namespace, function_name)

    generator_closure = "%s_closure" % generator

    _halide_library_instance(
        name = "%s.library_instance" % name,
        compatible_with = compatible_with,
        function_name = function_name,
        generator_closure = generator_closure,
        generator_params = generator_params,
        library_name = "//%s:%s" % (native.package_name(), name),
        target_features = halide_target_features,
        testonly = testonly,
        visibility = ["//visibility:private"],
    )
    hl_instance = ":%s.library_instance" % name

    condition_deps = {}
    for base_target, cfgs in _HALIDE_TARGET_CONFIG_SETTINGS_MAP.items():
        base_target_name = _halide_target_to_bazel_rule_name(base_target)
        gengen_name = "%s_%s" % (base_target_name, name)
        _gengen(
            name = gengen_name,
            compatible_with = compatible_with,
            consider_halide_extra_outputs = True,
            filename = "%s/%s" % (base_target_name, name),
            function_name = hl_instance,
            generator_binary = generator_closure,
            generator_name_ = generator_closure,
            generator_params = hl_instance,
            halide_base_target = base_target,
            halide_target_map = halide_target_map,
            library_name = hl_instance,
            requested_outputs = ["static_library"],
            tags = ["manual"] + tags,
            target_features = hl_instance,
            testonly = testonly,
        )
        for cfg in cfgs:
            condition_deps[cfg] = [":%s" % gengen_name]

    # Use a canonical target to build CC, regardless of config detected
    cc_base_target = "x86-64-linux"

    for output, target_name in [
        ("c_header", "%s_h" % name),
        ("c_source", "%s_cc" % name),
    ]:
        _gengen(
            name = target_name,
            compatible_with = compatible_with,
            filename = name,
            function_name = hl_instance,
            generator_binary = generator_closure,
            generator_name_ = generator_closure,
            generator_params = hl_instance,
            halide_base_target = cc_base_target,
            library_name = hl_instance,
            requested_outputs = [output],
            tags = ["manual"] + tags,
            target_features = hl_instance,
            testonly = testonly,
        )

    _select_halide_library_runtime(
        name = "%s.halide_library_runtime_deps" % name,
        halide_target_features = halide_target_features,
        compatible_with = compatible_with,
        tags = tags,
        visibility = ["//visibility:private"],
    )

    native.filegroup(
        name = "%s_object" % name,
        srcs = select(condition_deps),
        output_group = "generated_object",
        visibility = ["//visibility:private"],
        compatible_with = compatible_with,
        tags = tags,
        testonly = testonly,
    )

    native.cc_library(
        name = name,
        srcs = ["%s_object" % name],
        hdrs = [
            ":%s_h" % name,
        ],
        deps = deps +
               ["@halide//:runtime"] +  # for HalideRuntime.h, etc
               ([":%s.halide_library_runtime_deps" % name] if add_halide_runtime_deps else []),  # for the runtime implementation
        defines = ["HALIDE_FUNCTION_ATTRS=HALIDE_MUST_USE_RESULT"],
        compatible_with = compatible_with,
        includes = includes,
        tags = tags,
        testonly = testonly,
        visibility = visibility,
        linkstatic = 1,
    )

    # Return the fully-qualified built target name.
    return "//%s:%s" % (native.package_name(), name)

def halide_library(
        name,
        srcs = [],
        add_halide_runtime_deps = True,
        copts = [],
        compatible_with = [],
        filter_deps = [],
        function_name = None,
        generator_params = [],
        generator_deps = [],
        generator_name = None,
        halide_target_features = [],
        halide_target_map = halide_library_default_target_map(),
        includes = [],
        namespace = None,
        tags = [],
        testonly = False,
        visibility = None):
    if not srcs and not generator_deps:
        fail("halide_library needs at least one of srcs or generator_deps to provide a generator")

    halide_generator(
        name = "%s.generator" % name,
        srcs = srcs,
        compatible_with = compatible_with,
        generator_name = generator_name,
        deps = generator_deps,
        includes = includes,
        copts = copts,
        tags = tags,
        testonly = testonly,
        visibility = visibility,
    )

    return halide_library_from_generator(
        name = name,
        generator = ":%s.generator" % name,
        add_halide_runtime_deps = add_halide_runtime_deps,
        compatible_with = compatible_with,
        deps = filter_deps,
        function_name = function_name,
        generator_params = generator_params,
        halide_target_features = halide_target_features,
        halide_target_map = halide_target_map,
        includes = includes,
        namespace = namespace,
        tags = tags,
        testonly = testonly,
        visibility = visibility,
    )