configure_bazel.py

# Copyright 2020 The IREE Authors
#
# Licensed under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

import platform
import os
import shutil
import sys

IREE_CUDA_DEPS_DIR_ENV_KEY = "IREE_CUDA_DEPS_DIR"
IREE_CUDA_TOOLKIT_ROOT_ENV_KEY = "IREE_CUDA_TOOLKIT_ROOT"
VULKAN_SDK_ENV_KEY = "VULKAN_SDK"


def detect_unix_platform_config(bazelrc):
    # This is hoaky. Ideally, bazel had any kind of rational way of selecting
    # options from within its environment (key word: "rational"), but sadly, it
    # is unintelligible to mere mortals. Why should a build system have a way for
    # people to condition their build options on what compiler they are using
    # (without descending down the hole of deciphering what a Bazel toolchain is)?
    # All I want to do is set a couple of project specific warning options!

    if platform.system() == "Darwin":
        print(f"build --config=macos_clang", file=bazelrc)
        print(f"build:release --config=macos_clang_release", file=bazelrc)
    else:
        # If the user specified a CXX environment var, bazel will later respect that,
        # so we just see if it says "clang".
        cxx = os.environ.get("CXX")
        cc = os.environ.get("CC")
        if (cxx is not None and cc is None) or (cxx is None and cc is not None):
            print(
                "WARNING: Only one of CXX or CC is set, which can confuse bazel. "
                "Recommend: set both appropriately (or none)"
            )
        if cc is not None and cxx is not None:
            # Persist the variables.
            print(f'build --action_env CC="{cc}"', file=bazelrc)
            print(f'build --action_env CXX="{cxx}"', file=bazelrc)
        else:
            print(
                "WARNING: CC and CXX are not set, which can cause mismatches between "
                "flag configurations and compiler. Recommend setting them explicitly."
            )

        if cxx is not None and "clang" in cxx:
            print(f"Choosing generic_clang config because CXX is set to clang ({cxx})")
            print(f"build --config=generic_clang", file=bazelrc)
            print(f"build:release --config=generic_clang_release", file=bazelrc)
        else:
            print(
                f"Choosing generic_gcc config by default because no CXX set or "
                f"not recognized as clang ({cxx})"
            )
            print(f"build --config=generic_gcc", file=bazelrc)
            print(f"build:release --config=generic_gcc_release", file=bazelrc)


def write_platform(bazelrc):
    if platform.system() == "Windows":
        print(f"build --config=msvc", file=bazelrc)
        print(f"build:release --config=msvc_release", file=bazelrc)
    else:
        detect_unix_platform_config(bazelrc)


def cmake_bool_is_true(value):
    """Check if a CMake-style bool value is true."""
    if not value:
        return False
    return value.upper() in ("ON", "YES", "TRUE", "Y", "1")


def is_cuda_toolkit_root(path):
    """Check if a directory is a CUDA toolkit root usable by @iree_cuda."""
    return bool(path) and os.path.isfile(
        os.path.join(path, "nvvm", "libdevice", "libdevice.10.bc")
    )


def find_cuda_toolkit_root():
    """Find a CUDA toolkit root usable by the Bazel @iree_cuda repository."""
    for env_var in [
        IREE_CUDA_TOOLKIT_ROOT_ENV_KEY,
        IREE_CUDA_DEPS_DIR_ENV_KEY,
        "CUDA_ROOT",
        "CUDA_HOME",
        "CUDA_PATH",
        "CUDA_TOOLKIT_ROOT_DIR",
    ]:
        env_path = os.environ.get(env_var)
        if is_cuda_toolkit_root(env_path):
            return env_path, env_var

    nvcc_path = shutil.which("nvcc")
    if nvcc_path:
        nvcc_toolkit_root = os.path.dirname(
            os.path.dirname(os.path.realpath(nvcc_path))
        )
        if is_cuda_toolkit_root(nvcc_toolkit_root):
            return nvcc_toolkit_root, "nvcc"

    return None, None


def detect_cuda_toolkit():
    """Check if CUDA toolkit is available for Bazel plugin builds."""
    toolkit_root, _ = find_cuda_toolkit_root()
    return toolkit_root is not None


def is_vulkan_sdk_root(path):
    """Check if a directory is a Vulkan SDK root usable by @vulkan_sdk."""
    if not path:
        return False
    if platform.system() == "Windows":
        return os.path.isfile(os.path.join(path, "Lib", "vulkan-1.lib"))
    return os.path.isfile(os.path.join(path, "lib", "libvulkan.so.1"))


def normalize_vulkan_sdk_root(path):
    """Return the SDK subdirectory shape expected by LLVM's Vulkan SDK rule."""
    if not path:
        return None
    path = os.path.realpath(os.path.expanduser(path))
    for candidate in [
        path,
        os.path.join(path, "x86_64"),
    ]:
        if is_vulkan_sdk_root(candidate):
            return candidate
    return None


def find_vulkan_sdk_root():
    """Find a Vulkan SDK root usable by LLVM's Bazel @vulkan_sdk repository."""
    env_vulkan_sdk = os.environ.get(VULKAN_SDK_ENV_KEY)
    vulkan_sdk_root = normalize_vulkan_sdk_root(env_vulkan_sdk)
    if vulkan_sdk_root:
        return vulkan_sdk_root, VULKAN_SDK_ENV_KEY
    if env_vulkan_sdk:
        print(
            f"WARNING: {VULKAN_SDK_ENV_KEY} is set but does not contain a "
            "Vulkan SDK layout usable by Bazel"
        )

    vulkaninfo_path = shutil.which("vulkaninfo")
    if vulkaninfo_path:
        vulkaninfo_sdk_root = os.path.dirname(
            os.path.dirname(os.path.realpath(vulkaninfo_path))
        )
        vulkan_sdk_root = normalize_vulkan_sdk_root(vulkaninfo_sdk_root)
        if vulkan_sdk_root:
            return vulkan_sdk_root, "vulkaninfo"

    candidate_roots = []
    if platform.system() == "Windows":
        candidate_roots.append(r"C:\VulkanSDK")
    else:
        candidate_roots.extend(
            [
                "/opt/vulkan",
                "/opt/VulkanSDK",
                os.path.expanduser("~/VulkanSDK"),
            ]
        )

    for root in candidate_roots:
        vulkan_sdk_root = normalize_vulkan_sdk_root(root)
        if vulkan_sdk_root:
            return vulkan_sdk_root, root
        if os.path.isdir(root):
            for child in sorted(os.listdir(root), reverse=True):
                vulkan_sdk_root = normalize_vulkan_sdk_root(os.path.join(root, child))
                if vulkan_sdk_root:
                    return vulkan_sdk_root, root

    return None, None


def detect_rocm_toolkit():
    """Check if ROCm toolkit is available.

    Follows MLIR's search order: ROCM_PATH, ROCM_ROOT, ROCM_HOME, HIP_PATH,
    then hipcc in PATH.
    """
    for env_var in ["ROCM_PATH", "ROCM_ROOT", "ROCM_HOME", "HIP_PATH"]:
        if os.environ.get(env_var):
            return True
    if shutil.which("hipcc"):
        return True
    return False


def detect_submodule(submodule_path):
    """Check if a submodule is initialized by looking for a marker file.

    Args:
        submodule_path: Path relative to repo root (e.g., "third_party/torch-mlir")

    Returns:
        True if the submodule appears to be initialized.
    """
    script_dir = os.path.dirname(os.path.abspath(__file__))
    # Check for CMakeLists.txt as a common marker that the submodule has content
    marker = os.path.join(script_dir, submodule_path, "CMakeLists.txt")
    return os.path.isfile(marker)


def get_hal_driver_defaults():
    """Get HAL driver defaults matching CMake option(IREE_HAL_DRIVER_*) definitions."""
    defaults_enabled = True  # Matches IREE_HAL_DRIVER_DEFAULTS in CMakeLists.txt

    return {
        "AMDGPU": False,
        "CUDA": False,
        "HIP": False,
        "LOCAL_SYNC": defaults_enabled,
        "LOCAL_TASK": defaults_enabled,
        "METAL": platform.system() == "Darwin" and defaults_enabled,
        "NULL": False,  # Special: OFF in tests, ON otherwise
        "VULKAN": defaults_enabled and platform.system() not in ("Android", "iOS"),
    }


def env_var_to_bazel_tag(name):
    """Convert env var name to Bazel tag format.

    Bazel tags use hyphens: local-task, vulkan-spirv
    Env vars use underscores: IREE_HAL_DRIVER_LOCAL_TASK
    """
    if name.startswith("IREE_HAL_DRIVER_"):
        tag_name = name[len("IREE_HAL_DRIVER_") :]
    else:
        tag_name = name
    return tag_name.lower().replace("_", "-")


def get_plugin_defaults():
    """Get compiler plugin defaults matching CMake option definitions.

    Returns a dict mapping plugin_id -> (default_enabled, env_var_name, can_build).
    The can_build field indicates whether the plugin can be built on this system
    (e.g., CUDA requires toolkit, some input plugins require submodules).
    """
    cuda_available = detect_cuda_toolkit()
    rocm_available = detect_rocm_toolkit()
    stablehlo_available = detect_submodule("third_party/stablehlo")
    torch_mlir_available = detect_submodule("third_party/torch-mlir")
    return {
        # Input plugins (require submodules)
        "input_stablehlo": (True, "IREE_INPUT_STABLEHLO", stablehlo_available),
        "input_tosa": (True, "IREE_INPUT_TOSA", True),  # Part of MLIR, no submodule
        "input_torch": (False, "IREE_INPUT_TORCH", torch_mlir_available),
        # Target plugins
        "hal_target_cuda": (False, "IREE_TARGET_BACKEND_CUDA", cuda_available),
        "hal_target_llvm_cpu": (True, "IREE_TARGET_BACKEND_LLVM_CPU", True),
        "hal_target_local": (True, "IREE_TARGET_BACKEND_LOCAL", True),
        "hal_target_metal_spirv": (True, "IREE_TARGET_BACKEND_METAL_SPIRV", True),
        "hal_target_rocm": (False, "IREE_TARGET_BACKEND_ROCM", rocm_available),
        "hal_target_vmvx": (True, "IREE_TARGET_BACKEND_VMVX", True),
        "hal_target_vulkan_spirv": (True, "IREE_TARGET_BACKEND_VULKAN_SPIRV", True),
        # Sample plugins (always buildable)
        "example": (True, None, True),
        "simple_io_sample": (True, None, True),
    }


def parse_plugin_spec(spec, plugin_defaults):
    """Parse a plugin specification that may include 'all' and exclusions.

    Supports:
      - "all" - all plugins that can be built on this system
      - "all,-plugin1,-plugin2" - all except specified plugins
      - "plugin1,plugin2" - explicit list

    Returns a tuple (plugin_list, used_all) where used_all indicates whether
    "all" expansion was performed, or (None, False) if no spec provided.
    """
    if not spec:
        return None, False

    parts = [p.strip().lower() for p in spec.split(",") if p.strip()]
    if not parts:
        return [], False

    if parts[0] == "all":
        # Start with all buildable plugins
        enabled = set(
            plugin_id
            for plugin_id, (_, _, can_build) in plugin_defaults.items()
            if can_build
        )

        # Process exclusions
        for part in parts[1:]:
            if not part.startswith("-"):
                print(
                    f"ERROR: Expected plugin exclusion after 'all' but got '{part}'. "
                    f"Use 'all,-{part}' to exclude it."
                )
                sys.exit(1)
            plugin_to_exclude = part[1:]
            if plugin_to_exclude not in plugin_defaults:
                print(f"ERROR: Unknown plugin in exclusion: {plugin_to_exclude}")
                sys.exit(1)
            enabled.discard(plugin_to_exclude)

        return sorted(enabled), True
    else:
        # Explicit list - validate plugins exist and can be built
        validated = []
        for plugin_id in parts:
            if plugin_id not in plugin_defaults:
                print(f"ERROR: Unknown plugin: {plugin_id}")
                sys.exit(1)
            _, _, can_build = plugin_defaults[plugin_id]
            if not can_build:
                print(
                    f"ERROR: Plugin '{plugin_id}' requested but cannot be built "
                    f"(missing toolkit/submodule). Either install prerequisites or "
                    f"remove from IREE_COMPILER_PLUGINS."
                )
                sys.exit(1)
            validated.append(plugin_id)
        return validated, False


def write_iree_plugin_options(bazelrc):
    """Write compiler plugin configuration to bazelrc."""
    plugin_defaults = get_plugin_defaults()

    # Check for IREE_COMPILER_PLUGINS env var with "all" support
    plugins_spec = os.environ.get("IREE_COMPILER_PLUGINS")
    parsed_plugins, used_all = parse_plugin_spec(plugins_spec, plugin_defaults)

    if parsed_plugins is not None:
        # Explicit specification via IREE_COMPILER_PLUGINS
        enabled_plugins = parsed_plugins
        if used_all:
            print(
                f"IREE_COMPILER_PLUGINS=all resolved to: {', '.join(enabled_plugins)}"
            )
        else:
            print(f"IREE_COMPILER_PLUGINS set to: {', '.join(enabled_plugins)}")
    else:
        # Standard per-plugin env var processing
        enabled_plugins = []
        for plugin_id, (default, env_var, can_build) in plugin_defaults.items():
            if env_var:
                env_value = os.environ.get(env_var)
                enabled = (
                    cmake_bool_is_true(env_value) if env_value is not None else default
                )
            else:
                enabled = default

            if enabled:
                if not can_build:
                    print(
                        f"WARNING: {plugin_id} enabled but toolkit not detected, skipping"
                    )
                else:
                    enabled_plugins.append(plugin_id)

    # Write --iree_compiler_plugins flag (controls what gets built and linked)
    # Always emit the flag, even for empty list, so Bazel doesn't fall back to defaults.
    print(f'build --iree_compiler_plugins={",".join(enabled_plugins)}', file=bazelrc)

    # Persist the CUDA repository environment variable so Bazel sees the same
    # toolkit root that plugin selection detected.
    if "hal_target_cuda" in enabled_plugins:
        cuda_toolkit_root, cuda_source = find_cuda_toolkit_root()
        if cuda_source == IREE_CUDA_DEPS_DIR_ENV_KEY:
            cuda_env_key = IREE_CUDA_DEPS_DIR_ENV_KEY
        else:
            cuda_env_key = IREE_CUDA_TOOLKIT_ROOT_ENV_KEY
        print(f"common --repo_env={cuda_env_key}={cuda_toolkit_root}", file=bazelrc)


def write_vulkan_sdk_options(bazelrc):
    """Write Vulkan SDK repository configuration to bazelrc when available."""
    vulkan_sdk_root, vulkan_source = find_vulkan_sdk_root()
    if not vulkan_sdk_root:
        return
    print(f"Detected Vulkan SDK at {vulkan_sdk_root} via {vulkan_source}")
    print(f"common --repo_env={VULKAN_SDK_ENV_KEY}={vulkan_sdk_root}", file=bazelrc)


def write_iree_hal_driver_options(bazelrc):
    """Write HAL driver configuration to bazelrc."""

    # Get defaults matching CMake
    hal_drivers = get_hal_driver_defaults()

    # Apply environment overrides
    enabled_drivers = []
    for driver, default in hal_drivers.items():
        env_var = f"IREE_HAL_DRIVER_{driver}"
        env_value = os.environ.get(env_var)
        enabled = cmake_bool_is_true(env_value) if env_value is not None else default

        if enabled:
            enabled_drivers.append(env_var_to_bazel_tag(env_var))

    # Write --iree_runtime_drivers flag (controls what gets built and linked)
    if enabled_drivers:
        print(f'build --iree_runtime_drivers={",".join(enabled_drivers)}', file=bazelrc)
        print(f'test --iree_runtime_drivers={",".join(enabled_drivers)}', file=bazelrc)


if len(sys.argv) > 1:
    local_bazelrc = sys.argv[1]
else:
    local_bazelrc = os.path.join(os.path.dirname(__file__), "configured.bazelrc")
with open(local_bazelrc, "wt") as bazelrc:
    write_platform(bazelrc)
    write_iree_hal_driver_options(bazelrc)
    write_vulkan_sdk_options(bazelrc)
    write_iree_plugin_options(bazelrc)

print("Wrote", local_bazelrc)