OpenROAD/BUILD.bazel

# SPDX-License-Identifier: BSD-3-Clause
# Copyright (c) 2025-2025, The OpenROAD Authors

load("@bazel_skylib//rules:build_test.bzl", "build_test")
load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_python//python:defs.bzl", "py_library")
load("@rules_shell//shell:sh_binary.bzl", "sh_binary")
load("@rules_shell//shell:sh_test.bzl", "sh_test")
load("//bazel:python_wrap_cc.bzl", "PYTHON_EXTENSION_LINKOPTS", "PYTHON_STABLE_API_DEFINE", "python_wrap_cc")
load("//bazel:tcl_encode_or.bzl", "tcl_encode")
load("//bazel:tcl_wrap_cc.bzl", "tcl_wrap_cc")
load("//test:regression.bzl", "messages_txt")

package(
    features = [
        "parse_headers",
        "layering_check",
        # TODO(b/299593765): Fix strict ordering.
        "-libcxx_assertions",
    ],
)

exports_files([
    ".clang-tidy",
    "BUILD.bazel",
    "LICENSE",
    "MODULE.bazel",
    "README.md",
    "src/Design.i",
    "src/Exception.i",
    "src/options.i",
])

string_flag(
    name = "platform",
    build_setting_default = "cli",
    values = [
        "cli",
        "gui",
    ],
)

config_setting(
    name = "platform_cli",
    flag_values = {
        ":platform": "cli",
    },
)

config_setting(
    name = "platform_gui",
    flag_values = {
        ":platform": "gui",
    },
)

OPENROAD_LIBRARY_DEPS = [
    ":openroad_version",
    "//src/ant",
    "//src/ant:ui",
    "//src/cgt",
    "//src/cts",
    "//src/cts:ui",
    "//src/dbSta",
    "//src/dbSta:dbNetwork",
    "//src/dbSta:dbReadVerilog",
    "//src/dbSta:ui",
    "//src/dft",
    "//src/dft:ui",
    "//src/dpl",
    "//src/dpl:ui",
    "//src/drt",
    "//src/drt:ui",
    "//src/dst",
    "//src/dst:ui",
    "//src/est",
    "//src/est:ui",
    "//src/exa",
    "//src/exa:ui",
    "//src/fin",
    "//src/gpl",
    "//src/gpl:ui",
    "//src/grt",
    "//src/grt:ui",
    "//src/ifp",
    "//src/ifp:ui",
    "//src/mpl",
    "//src/mpl:ui",
    "//src/odb/src/3dblox",
    "//src/odb/src/cdl",
    "//src/odb/src/db",
    "//src/odb/src/defin",
    "//src/odb/src/defout",
    "//src/odb/src/lefin",
    "//src/odb/src/lefout",
    "//src/odb:ui",
    "//src/pad",
    "//src/par",
    "//src/par:ui",
    "//src/pdn",
    "//src/ppl",
    "//src/psm",
    "//src/ram",
    "//src/rcx",
    "//src/rcx:ui",
    "//src/rmp",
    "//src/rmp:ui",
    "//src/rsz",
    "//src/rsz:ui",
    "//src/stt:ui",
    "//src/syn",
    "//src/syn:ui",
    "//src/tap",
    "//src/tap:ui",
    "//src/upf:ui",
    "//src/utl",
    "//src/utl:ui",
    "//src/web",
    "//src/web:ui",
    ":ord",
]

# Flags applied to top-level OpenROAD targets only. Flags that apply
# globally to every cc_* target (-Wall, -Wextra, -Wno-sign-compare,
# -Wno-unused-parameter, etc.) live in .bazelrc — do not repeat them here.
OPENROAD_COPTS = [
    "-Wno-error",
    "-pedantic",
    "-Wno-cast-qual",  # typically from TCL swigging
    "-Wno-missing-braces",  # typically from TCL swigging
    "-Wredundant-decls",
    "-Wformat-security",
    "-Wmismatched-tags",
    "-fopenmp",
]

OPENROAD_DEFINES = [
    "BUILD_TYPE=\\\"$(COMPILATION_MODE)\\\"",
    "BAZEL_BUILD",
    "GPU=false",
    "BUILD_PYTHON=false",
    "ABC_NAMESPACE=abc",
]

cc_library(
    name = "cli_completer",
    srcs = ["src/cli_completer.cc"],
    hdrs = ["src/cli_completer.h"],
    includes = ["src"],
    visibility = ["//visibility:public"],
    deps = [
        "@tcl_lang//:tcl",
    ],
)

cc_library(
    name = "tcl_readline_setup",
    srcs = ["src/tcl_readline_setup.cc"],
    hdrs = ["src/tcl_readline_setup.h"],
    includes = ["src"],
    visibility = ["//src/sta:__pkg__"],
    deps = [
        ":cli_completer",
        "//third-party/linenoise",
        "@tcl_lang//:tcl",
    ],
)

# Deps shared by :openroad and :openroad-qt. Kept as a Starlark list
# rather than a cc_library wrapper because layering_check is enabled
# package-wide: a deps-only cc_library does not re-export its deps'
# headers to consumers, so direct binary deps are what each Main.cc
# include needs to see.
OPENROAD_MAIN_DEPS = [
    ":ord",
    ":tcl_readline_setup",
    "//bazel:tcl_library_init",
    "//src/cut",
    "//src/sta:opensta_lib",
    "//src/utl",
    "//src/web",
    "@abseil-cpp//absl/base:no_destructor",
    "@boost.stacktrace",
    "@tcl_lang//:tcl",
]

cc_binary(
    name = "openroad",
    srcs = [
        "src/Main.cc",
    ],
    copts = OPENROAD_COPTS,
    defines = OPENROAD_DEFINES,
    features = ["-use_header_modules"],
    malloc = select({
        "@platforms//os:linux": "@tcmalloc//tcmalloc",
        "@platforms//os:macos": "@bazel_tools//tools/cpp:malloc",
    }),
    visibility = ["//visibility:public"],
    deps = OPENROAD_MAIN_DEPS + select(
        {
            ":platform_cli": [
                ":openroad_lib",
                "//src/gui",
                "//src/gui:gui_stub",
            ],
            ":platform_gui": [
                ":openroad_lib_qt",
                "//src/gui:gui_qt",
            ],
        },
    ),
)

# Qt GUI variant. Build explicitly when the interactive GUI is wanted:
#   bazelisk build //:openroad-qt
# Additive to the existing `--//:platform=gui //:openroad` flag path —
# this target is preferable for ad-hoc GUI builds because it does not
# invalidate `:openroad`'s cache the way flipping the flag does.
cc_binary(
    name = "openroad-qt",
    srcs = [
        "src/Main.cc",
    ],
    copts = OPENROAD_COPTS,
    defines = OPENROAD_DEFINES,
    features = ["-use_header_modules"],
    malloc = select({
        "@platforms//os:linux": "@tcmalloc//tcmalloc",
        "@platforms//os:macos": "@bazel_tools//tools/cpp:malloc",
    }),
    visibility = ["//visibility:public"],
    deps = OPENROAD_MAIN_DEPS + [
        ":openroad_lib_qt",
        "//src/gui:gui_qt",
    ],
)

# CLI variant: the default. What downstream rule libraries pull as a
# build-time tool, and what `bazelisk build //:openroad` produces.
cc_library(
    name = "openroad_lib",
    srcs = [
        "src/Design.cc",
        "src/OpenRoad.cc",
        "src/Tech.cc",
        "src/Timing.cc",
        ":openroad_swig",
        ":openroad_tcl",
    ],
    copts = OPENROAD_COPTS,
    defines = OPENROAD_DEFINES + ["BUILD_GUI=false"],
    features = ["-use_header_modules"],
    includes = [
        "include",
    ],
    visibility = ["//:__subpackages__"],
    deps = [
        "//src/gui",
        "//src/sta:opensta_lib",
        "@abseil-cpp//absl/base:core_headers",
        "@abseil-cpp//absl/synchronization",
        "@boost.stacktrace",
        "@tcl_lang//:tcl",
    ] + OPENROAD_LIBRARY_DEPS,
)

# Qt variant: same sources, linked against the Qt GUI implementation.
# Used by :openroad-qt, and by :openroad when --//:platform=gui is set.
# Compiled separately (different `BUILD_GUI` define + different gui dep).
cc_library(
    name = "openroad_lib_qt",
    srcs = [
        "src/Design.cc",
        "src/OpenRoad.cc",
        "src/Tech.cc",
        "src/Timing.cc",
        ":openroad_swig",
        ":openroad_tcl",
    ],
    copts = OPENROAD_COPTS,
    defines = OPENROAD_DEFINES + ["BUILD_GUI=true"],
    features = ["-use_header_modules"],
    includes = [
        "include",
    ],
    visibility = ["//:__subpackages__"],
    deps = [
        "//src/gui:gui_qt",
        "//src/sta:opensta_lib",
        "@abseil-cpp//absl/base:core_headers",
        "@abseil-cpp//absl/synchronization",
        "@boost.stacktrace",
        "@tcl_lang//:tcl",
    ] + OPENROAD_LIBRARY_DEPS,
)

cc_library(
    name = "ord",
    hdrs = [
        "include/ord/Design.h",
        "include/ord/InitOpenRoad.hh",
        "include/ord/OpenRoad.hh",
        "include/ord/Tech.h",
        "include/ord/Timing.h",
    ],
    includes = [
        "include",
    ],
    visibility = ["//:__subpackages__"],
    deps = [
        "//src/sta:opensta_lib",
        "@abseil-cpp//absl/synchronization",
        "@tcl_lang//:tcl",
    ],
)

cc_library(
    name = "openroad_version",
    hdrs = [
        ":OpenRoadVersion",
    ],
    includes = [
        "include",
    ],
)

genrule(
    name = "OpenRoadVersion",
    srcs = [],
    outs = ["include/ord/Version.hh"],
    cmd = """
        VERSION=""
        if [ -f bazel-out/stable-status.txt ]; then
            VERSION=$$(grep '^STABLE_GIT_VERSION ' bazel-out/stable-status.txt \
                        | cut -d' ' -f2-) || true
        fi
        [ -z "$$VERSION" ] && VERSION="bazel-nostamp"
        printf '#define OPENROAD_VERSION "%s"\\n' "$$VERSION" > $@
        printf '#define OPENROAD_GIT_DESCRIBE ""\\n' >> $@
    """,
    # stamp = -1 means "stamp when --stamp is set" (via --config=release).
    # Without --stamp (the default), STABLE_GIT_VERSION is empty and
    # the output is deterministic, so the Bazel cache is not invalidated
    # on every commit.
    stamp = -1,
)

tcl_encode(
    name = "openroad_tcl",
    srcs = ["//src/sta:tcl_util"] + [
        "src/Metrics.tcl",
        "src/OpenRoad.tcl",
    ],
    char_array_name = "ord_tcl_inits",
    namespace = "ord",
)

tcl_wrap_cc(
    name = "openroad_swig",
    srcs = [
        "src/OpenRoad.i",
        ":error_swig",
    ],
    module = "ord",
    namespace_prefix = "ord",
    root_swig_src = "src/OpenRoad.i",
    swig_includes = [
        "src",
    ],
)

cc_binary(
    name = "_openroadpy.so",
    srcs = [":openroad_swig-py"],
    defines = [PYTHON_STABLE_API_DEFINE],
    linkopts = PYTHON_EXTENSION_LINKOPTS,
    linkshared = True,
    deps = [
        ":openroad_lib",
        ":ord",
        "//src/ant",
        "//src/cgt",
        "//src/cts",
        "//src/dpl",
        "//src/drt",
        "//src/exa",
        "//src/fin",
        "//src/gpl",
        "//src/grt",
        "//src/gui",
        "//src/gui:gui_stub",
        "//src/ifp",
        "//src/odb/src/db",
        "//src/par",
        "//src/pdn",
        "//src/ppl",
        "//src/psm",
        "//src/rcx",
        "//src/rsz",
        "//src/stt",
        "//src/tap",
        "//src/utl",
        "@boost.stacktrace",
        "@rules_python//python/cc:current_py_cc_headers",
    ],
)

py_library(
    name = "openroad_py",
    srcs = [":openroad_swig-py"],
    data = [":_openroadpy.so"],
    imports = ["."],
    visibility = ["//visibility:public"],
    deps = [
        "//src/gpl:gpl_py",
        "//src/odb:odb_py",
        "//src/utl:utl_py",
    ],
)

python_wrap_cc(
    name = "openroad_swig-py",
    srcs = [
        "include/ord/Design.h",
        "include/ord/Tech.h",
        "include/ord/Timing.h",
        "src/OpenRoad-py.i",
        ":error_swig-py",
    ],
    module = "openroadpy",
    root_swig_src = "src/OpenRoad-py.i",
    swig_includes = [
        "include",
        "src",
    ],
    deps = [
        "//src/ant:swig-py",
        "//src/cgt:swig-py",
        "//src/cts:swig-py",
        "//src/dpl:swig-py",
        "//src/drt:swig-py",
        "//src/exa:swig-py",
        "//src/fin:swig-py",
        "//src/gpl:swig-py",
        "//src/grt:swig-py",
        "//src/ifp:swig-py",
        "//src/odb:swig-py",
        "//src/par:swig-py",
        "//src/pdn:swig-py",
        "//src/ppl:swig-py",
        "//src/psm:swig-py",
        "//src/rcx:swig-py",
        "//src/rsz:swig-py",
        "//src/stt:swig-py",
        "//src/tap:swig-py",
        "//src/utl:swig-py",
    ],
)

filegroup(
    name = "error_swig",
    srcs = [
        "src/Exception.i",
    ],
    visibility = ["//:__subpackages__"],
)

filegroup(
    name = "error_swig-py",
    srcs = [
        "src/Exception-py.i",
    ],
    visibility = ["//:__subpackages__"],
)

filegroup(
    name = "design_swig",
    srcs = [
        "src/Design.i",
    ],
)

filegroup(
    name = "options_swig",
    srcs = [
        "src/options.i",
    ],
    visibility = ["//:__subpackages__"],
)

# ---------------------------------------------------------------------------
# Packaging aliases
#
# The implementation lives in //packaging/ to isolate @rules_pkg loads from
# downstream consumers, but the user-facing targets stay at the top level.
# ---------------------------------------------------------------------------

alias(
    name = "install",
    actual = "//packaging:install",
    visibility = ["//visibility:public"],
)

alias(
    name = "tarfile",
    actual = "//packaging:tarfile",
    visibility = ["//visibility:public"],
)

# The ORD messages, which live in src/ itself rather than in a module
# subdirectory.
messages_txt(
    recursive = False,
    visibility = ["//visibility:public"],
)

# Lightweight test suites that run without building OpenROAD.
# Usage:
#   bazelisk test --test_tag_filters=doc_check //src/... # all documentation checks
#   bazelisk test //:dup_id_test                         # duplicate message ID check

# buildifier: disable=native-sh-test
sh_test(
    name = "dup_id_test",
    srcs = ["//etc:find_dup_ids.sh"],
    data = [
        # The handle the script uses to find the source tree it scans.
        "MODULE.bazel",
        "//etc:find_messages.py",
    ],
    # external: the sources being scanned are not declared inputs, so nothing
    # invalidates a cached result when one of them gains a duplicate ID. Without
    # this the check reports "(cached) PASSED" over a tree it never looked at.
    tags = [
        "external",
        "local",
    ],
)

# Make sure the Qt GUI variant keeps building. :openroad is exercised by
# downstream rule libraries that pull it as a tool; :openroad-qt has no
# such consumer in CI, so a build_test pins its compilability.
build_test(
    name = "openroad_qt_build_test",
    targets = [":openroad-qt"],
)

# ---------------------------------------------------------------------------
# Lint & tidy targets
#
# bazelisk test //:lint_test               — run all lint checks
# bazelisk run  //:fix_lint                — auto-fix then lint in OpenROAD
# bazelisk run  //tools/OpenROAD:fix_lint  — auto-fix then lint in ORFS / downstream repos
#
# Every check below enumerates the git worktree (git_ls_files.sh) rather than
# taking the files it inspects as declared inputs -- that is what lets one
# target cover the whole repo, including files no Bazel target references. The
# cost is that editing a file cannot invalidate a cached result, so each test is
# tagged "external" to force it to re-run. Without that they report
# "(cached) PASSED" over a worktree they never read.
# ---------------------------------------------------------------------------

# --- TCL linting (tclint) -------------------------------------------------

# buildifier: disable=native-sh-test
sh_test(
    name = "lint_tcl_test",
    srcs = ["//bazel:tcl_lint_test.sh"],
    args = [
        "$(rootpath //bazel:tclint)",
        "$(rootpath @git)",
    ],
    data = [
        "tclint.toml",
        "//bazel:git_ls_files.sh",
        "//bazel:tclint",
        "@git",
    ],
    tags = [
        "external",
        "local",
    ],
    visibility = ["//visibility:public"],
)

# --- TCL formatting check (tclfmt --check) --------------------------------

# buildifier: disable=native-sh-test
sh_test(
    name = "fmt_tcl_test",
    srcs = ["//bazel:tcl_fmt_test.sh"],
    args = [
        "$(rootpath //bazel:tclfmt)",
        "$(rootpath @git)",
    ],
    data = [
        "tclint.toml",
        "//bazel:git_ls_files.sh",
        "//bazel:tclfmt",
        "@git",
    ],
    tags = [
        "external",
        "local",
    ],
    visibility = ["//visibility:public"],
)

# --- TCL auto-format only (tclfmt --in-place) -----------------------------

# buildifier: disable=native-sh-binary
sh_binary(
    name = "tidy_tcl",
    srcs = ["//bazel:tcl_tidy.sh"],
    args = [
        "$(rootpath //bazel:tclfmt)",
        "$(rootpath @git)",
    ],
    data = [
        "tclint.toml",
        "//bazel:git_ls_files.sh",
        "//bazel:tclfmt",
        "@git",
    ],
    visibility = ["//visibility:public"],
)

# --- Bazel linting (buildifier -lint=warn) --------------------------------

# buildifier: disable=native-sh-test
sh_test(
    name = "lint_bzl_test",
    srcs = ["//bazel:bzl_lint_test.sh"],
    args = [
        "$(rootpath @buildifier_prebuilt//:buildifier)",
        "$(rootpath @git)",
    ],
    data = [
        "MODULE.bazel",
        "//bazel:git_ls_files.sh",
        "@buildifier_prebuilt//:buildifier",
        "@git",
    ],
    tags = [
        "external",
        "local",
    ],
    visibility = ["//visibility:public"],
)

# --- Bazel formatting check (buildifier -mode=check -lint=off) ------------

# buildifier: disable=native-sh-test
sh_test(
    name = "fmt_bzl_test",
    srcs = ["//bazel:bzl_fmt_test.sh"],
    args = [
        "$(rootpath @buildifier_prebuilt//:buildifier)",
        "$(rootpath @git)",
    ],
    data = [
        "MODULE.bazel",
        "//bazel:git_ls_files.sh",
        "@buildifier_prebuilt//:buildifier",
        "@git",
    ],
    tags = [
        "external",
        "local",
    ],
    visibility = ["//visibility:public"],
)

# --- Bazel auto-format only (buildifier -mode=fix) ------------------------

# buildifier: disable=native-sh-binary
sh_binary(
    name = "tidy_bzl",
    srcs = ["//bazel:bzl_tidy.sh"],
    args = [
        "$(rootpath @buildifier_prebuilt//:buildifier)",
        "$(rootpath @git)",
    ],
    data = [
        "//bazel:git_ls_files.sh",
        "@buildifier_prebuilt//:buildifier",
        "@git",
    ],
    visibility = ["//visibility:public"],
)

# --- YAML formatting check (yamlfix) ---------------------------------------

# buildifier: disable=native-sh-test
sh_test(
    name = "fmt_yaml_test",
    srcs = ["//bazel:yaml_fmt_test.sh"],
    args = [
        "$(rootpath //bazel:yamlfix)",
        "$(rootpath @git)",
    ],
    data = [
        "MODULE.bazel",
        "yamlfix.ignore",
        "yamlfix.toml",
        "//bazel:yamlfix",
        "@git",
    ],
    tags = [
        "external",
        "local",
    ],
    visibility = ["//visibility:public"],
)

# --- YAML auto-format only (yamlfix) ---------------------------------------

# buildifier: disable=native-sh-binary
sh_binary(
    name = "tidy_yaml",
    srcs = ["//bazel:yaml_tidy.sh"],
    args = [
        "$(rootpath //bazel:yamlfix)",
        "$(rootpath @git)",
    ],
    data = [
        "yamlfix.ignore",
        "yamlfix.toml",
        "//bazel:yamlfix",
        "@git",
    ],
    visibility = ["//visibility:public"],
)

# --- Umbrella targets ------------------------------------------------------

test_suite(
    name = "lint_test",
    tests = [
        ":fmt_bzl_test",
        ":fmt_tcl_test",
        ":fmt_yaml_test",
        ":lint_bzl_test",
        ":lint_tcl_test",
    ],
    visibility = ["//visibility:public"],
)

# Linting is done here (not just formatting) because not all lint violations
# are auto-fixable — fix_lint fixes what it can, then reports the rest.
# Downstream workspaces (such as OpenROAD-flow-scripts) can run this directly
# from their repo root via `bazelisk run //tools/OpenROAD:fix_lint`.
# buildifier: disable=native-sh-binary
sh_binary(
    name = "fix_lint",
    srcs = ["//bazel:fix_lint.sh"],
    args = [
        "$(rootpath //bazel:tcl_tidy.sh)",
        "$(rootpath //bazel:tclfmt)",
        "$(rootpath //bazel:tcl_lint_test.sh)",
        "$(rootpath //bazel:tclint)",
        "$(rootpath //bazel:bzl_tidy.sh)",
        "$(rootpath @buildifier_prebuilt//:buildifier)",
        "$(rootpath //bazel:bzl_lint_test.sh)",
        "$(rootpath @buildifier_prebuilt//:buildifier)",
        "$(rootpath @git)",
        "$(rootpath //bazel:yaml_tidy.sh)",
        "$(rootpath //bazel:yamlfix)",
    ],
    data = [
        "MODULE.bazel",
        "tclint.toml",
        "yamlfix.ignore",
        "yamlfix.toml",
        "//bazel:bzl_lint_test.sh",
        "//bazel:bzl_tidy.sh",
        "//bazel:git_ls_files.sh",
        "//bazel:tcl_lint_test.sh",
        "//bazel:tcl_tidy.sh",
        "//bazel:tclfmt",
        "//bazel:tclint",
        "//bazel:yaml_tidy.sh",
        "//bazel:yamlfix",
        "@buildifier_prebuilt//:buildifier",
        "@git",
    ],
    visibility = ["//visibility:public"],
)