Merge branch 'master' of https://github.com/The-OpenROAD-Project-private/OpenROAD into secure-hier-repair-tie-fanout

Signed-off-by: Jaehyun Kim <[email protected]>

Author: jhkim-pii

.github/workflows/github-actions-lint-tcl.yml

@@ -19,13 +19,13 @@ jobs:
       - name: Install Dependencies
         run: |
           python3 -m venv venv
-          venv/bin/pip install tclint==0.4.2
+          venv/bin/pip install tclint==0.6.1
 
       - name: Lint
         run: |
           source venv/bin/activate
           tclfmt --version
           tclfmt --in-place .
           git diff --exit-code
-          tclint --no-check-style .
+          tclint .
 

BUILD.bazel

@@ -4,6 +4,7 @@
 load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
 load("//bazel:tcl_encode_or.bzl", "tcl_encode")
 load("//bazel:tcl_wrap_cc.bzl", "tcl_wrap_cc")
+load("//bazel:python_wrap_cc.bzl", "python_wrap_cc", "PYTHON_STABLE_API_DEFINE")
 
 package(
     features = [
@@ -55,6 +56,10 @@ OPENROAD_LIBRARY_DEPS = [
     "//src/cts:ui",
     "//src/cut",
     "//src/dbSta",
+    "//src/dbSta:dbNetwork",
+    "//src/dbSta:dbReadVerilog",
+    "//src/dbSta:dbSdcNetwork",
+    "//src/dbSta:SpefWriter",
     "//src/dbSta:ui",
     "//src/dft",
     "//src/dft:ui",
@@ -133,23 +138,26 @@ cc_binary(
     name = "openroad",
     srcs = [
         "src/Main.cc",
-        "//bazel:runfiles",
     ],
     copts = OPENROAD_COPTS,
     features = ["-use_header_modules"],
-    malloc = "@tcmalloc//tcmalloc",
+    malloc = select({
+        "@platforms//os:linux": "@tcmalloc//tcmalloc",
+        "@platforms//os:macos": "@bazel_tools//tools/cpp:malloc",
+    }),
     visibility = ["//visibility:public"],
     deps = [
         ":openroad_lib",
         ":openroad_version",
-        "//:ord",
+        ":ord",
         "//src/cut",
         "//src/gui",
         "//src/sta:opensta_lib",
         "//src/utl",
         "@boost.stacktrace",
         "@rules_cc//cc/runfiles",
         "@tk_tcl//:tcl",
+        "//bazel:runfiles",
     ],
 )
 
@@ -262,6 +270,94 @@ tcl_wrap_cc(
     ],
 )
 
+
+# This target compiles the SWIG C++ wrapper into a shared library (.so)
+# that Python can load dynamically.
+cc_binary(
+    name = "_openroadpy.so",
+    srcs = [":openroad_swig-py"],
+    linkshared = True,
+    deps = [
+        ":openroad_lib",  # Depends on the core odb C++ library
+        ":ord",
+        "//src/odb",
+        "//src/ifp",
+        "//src/utl",
+        "//src/gpl",
+        "//src/ant",
+        "//src/cts",
+        "//src/dpl",
+        "//src/drt",
+        "//src/exa",
+        "//src/fin",
+        "//src/grt",
+        "//src/par",
+        "//src/pdn",
+        "//src/ppl",
+        "//src/psm",
+        "//src/rcx",
+        "//src/stt",
+        "//src/gui",
+        "//src/tap",
+        "@boost.stacktrace",
+        "@openroad_rules_python//python/cc:current_py_cc_headers",
+    ],
+    defines = [PYTHON_STABLE_API_DEFINE],
+)
+
+# This packages the SWIG-generated Python wrapper (odb.py) and the
+# compiled C++ extension (_odb.so) together.
+py_library(
+    name = "ord_py",
+    srcs = [":openroad_swig-py"],  # Use the .py output from the swig-py rule
+    # The data attribute makes the .so file available at runtime.
+    data = [":_openroadpy.so"],
+    deps = [
+        "//src/utl:utl_py",
+        "//src/odb:odb_py",
+    ],
+    # This allows imports relative to the workspace root.
+    imports = ["."],
+    visibility = ["//visibility:public",]
+)
+
+python_wrap_cc(
+    name = "openroad_swig-py",
+    srcs = [
+        "src/OpenRoad-py.i",
+        ":error_swig-py",
+        "include/ord/Tech.h",
+        "include/ord/Design.h",
+        "include/ord/Timing.h",
+    ],
+    module = "openroadpy",
+    root_swig_src = "src/OpenRoad-py.i",
+    swig_includes = [
+        "include",
+        "src",
+    ],
+    deps = [
+        "//src/gpl:swig-py",
+        "//src/ifp:swig-py",
+        "//src/ant:swig-py",
+        "//src/cts:swig-py",
+        "//src/dpl:swig-py",
+        "//src/drt:swig-py",
+        "//src/exa:swig-py",
+        "//src/fin:swig-py",
+        "//src/grt:swig-py",
+        "//src/par:swig-py",
+        "//src/pdn:swig-py",
+        "//src/ppl:swig-py",
+        "//src/psm:swig-py",
+        "//src/rcx:swig-py",
+        "//src/stt:swig-py",
+        "//src/tap:swig-py",
+        "//src/odb:swig-py",
+        "//src/utl:swig-py",
+    ]
+)
+
 filegroup(
     name = "error_swig",
     srcs = [
@@ -270,9 +366,17 @@ filegroup(
     visibility = ["@//:__subpackages__"],
 )
 
+filegroup(
+    name = "error_swig-py",
+    srcs = [
+        "src/Exception-py.i",
+    ],
+    visibility = ["@//:__subpackages__"],
+)
+
 filegroup(
     name = "design_swig",
     srcs = [
         "src/Design.i",
     ],
-)
+)

MODULE.bazel

@@ -138,6 +138,7 @@ python.toolchain(
     ignore_root_user_error = True,
     python_version = "3.13",
 )
+use_repo(python, "python_3_13")
 
 pip = use_extension("@openroad_rules_python//python/extensions:pip.bzl", "pip")
 pip.parse(

bazel/BUILD

@@ -16,4 +16,5 @@ cc_library(
     deps = [
         "@rules_cc//cc/runfiles",
     ],
+    alwayslink = True,
 )

bazel/InitRunFiles.cpp

@@ -6,6 +6,11 @@
 #include <optional>
 #include <string>
 
+#if defined(__APPLE__)
+#include <mach-o/dyld.h>
+#include <sys/param.h>
+#endif
+
 #include "rules_cc/cc/runfiles/runfiles.h"
 
 // Avoid adding any dependencies like boost.filesystem
@@ -19,7 +24,7 @@ static std::optional<std::string> getProgramLocation()
   char result[MAXPATHLEN + 1] = {'\0'};
   uint32_t path_len = MAXPATHLEN;
   if (_NSGetExecutablePath(result, &path_len) != 0) {
-    path_len = readlink("/proc/self/exe", result, MAXPATHLEN);
+    path_len = readlink(result, result, MAXPATHLEN);
   }
 #else
   char result[PATH_MAX + 1] = {'\0'};
@@ -50,9 +55,9 @@ class BazelInitializer
     }
 
     // Set the TCL_LIBRARY environment variable
-    std::string path = runfiles->Rlocation("tk_tcl/library/");
-    if (!path.empty()) {
-      setenv("TCL_LIBRARY", path.c_str(), 0);
+    const std::string tcl_path = runfiles->Rlocation("tk_tcl/library/");
+    if (!tcl_path.empty()) {
+      setenv("TCL_LIBRARY", tcl_path.c_str(), 0);
     } else {
       std::cerr << "Error: Could not locate 'tk_tcl/library/' in runfiles."
                 << std::endl;

bazel/python_wrap_cc.bzl

@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025-2025, The OpenROAD Authors
+
+"""A Python SWIG wrapping rule
+
+These rules generate a C++ src file that is expected to be used as srcs in
+cc_library or cc_binary rules. See below for expected usage.
+cc_library(srcs=[":python_foo"])
+python_wrap_cc(name = "python_foo", srcs=["exception.i"],...)
+"""
+PythonSwigInfo = provider(
+    "PythonSwigInfo for taking dependencies on other swig info rules",
+    fields = [
+        "transitive_srcs",
+        "includes",
+        "swig_options",
+    ],
+)
+
+PYTHON_STABLE_API_DEFINE = "Py_LIMITED_API=0x030A0000"
+
+def _get_transitive_srcs(srcs, deps):
+    return depset(
+        srcs,
+        transitive = [dep[PythonSwigInfo].transitive_srcs for dep in deps],
+    )
+
+def _get_transitive_includes(local_includes, deps):
+    return depset(
+        local_includes,
+        transitive = [dep[PythonSwigInfo].includes for dep in deps],
+    )
+
+def _get_transitive_options(options, deps):
+    return depset(
+        options,
+        transitive = [dep[PythonSwigInfo].swig_options for dep in deps],
+    )
+
+def _python_wrap_cc_impl(ctx):
+    """Generates a single C++ file from the provided srcs in a DefaultInfo."""
+    if len(ctx.files.srcs) > 1 and not ctx.attr.root_swig_src:
+        fail("If multiple src files are provided, root_swig_src must be specified.")
+
+    root_file = ctx.file.root_swig_src or ctx.files.srcs[0]
+
+    cc_outfile_name = ctx.attr.out or (ctx.attr.name + ".cc")
+    cc_output_file = ctx.actions.declare_file(cc_outfile_name)
+    py_outfile_name = ctx.attr.module + ".py"
+    py_output_file = ctx.actions.declare_file(py_outfile_name)
+
+    include_root_directory = ""
+    if ctx.label.package:
+        include_root_directory = ctx.label.package + "/"
+
+    src_inputs = _get_transitive_srcs(ctx.files.srcs + ctx.files.root_swig_src, ctx.attr.deps)
+    includes_paths = _get_transitive_includes(
+        ["{}{}".format(include_root_directory, include) for include in ctx.attr.swig_includes],
+        ctx.attr.deps,
+    )
+    swig_options = _get_transitive_options(ctx.attr.swig_options, ctx.attr.deps)
+
+    args = ctx.actions.args()
+    args.add("-DBAZEL=1")
+    args.add("-python")
+    args.add("-c++")
+    args.add("-flatstaticmethod")
+    args.add("-module")
+    args.add(ctx.attr.module)
+    args.add_all(swig_options.to_list())
+    args.add_all(includes_paths.to_list(), format_each = "-I%s")
+    args.add("-o")
+    args.add(cc_output_file.path)
+    args.add(root_file.path)
+
+    ctx.actions.run(
+        outputs = [cc_output_file, py_output_file],
+        inputs = src_inputs,
+        arguments = [args],
+        tools = ctx.files._swig,
+        executable = ([file for file in ctx.files._swig if file.basename == "swig"][0]),
+    )
+    return [
+        DefaultInfo(files = depset([cc_output_file, py_output_file])),
+        PythonSwigInfo(
+            transitive_srcs = src_inputs,
+            includes = includes_paths,
+            swig_options = swig_options,
+        ),
+    ]
+
+python_wrap_cc = rule(
+    implementation = _python_wrap_cc_impl,
+    attrs = {
+        "deps": attr.label_list(
+            allow_empty = True,
+            doc = "python_wrap_cc dependencies",
+            providers = [PythonSwigInfo],
+        ),
+        "module": attr.string(
+            mandatory = True,
+            doc = "swig module",
+        ),
+        "out": attr.string(
+            doc = "The name of the C++ source file generated by these rules. If not set, defaults to '<name>.cc'.",
+        ),
+        "root_swig_src": attr.label(
+            allow_single_file = [".swig", ".i"],
+            doc = """If more than one swig file is included in this rule.
+            The root file must be explicitly provided. This is the file which will be passed to
+            swig for generation.""",
+        ),
+        "srcs": attr.label_list(
+            allow_empty = False,
+            allow_files = [".i", ".swig", ".h", ".hpp", ".hh"],
+            doc = "Swig files that generate C++ files",
+        ),
+        "swig_includes": attr.string_list(
+            doc = "List of directories relative to the BUILD file to append as -I flags to SWIG",
+        ),
+        "swig_options": attr.string_list(
+            doc = "args to pass directly to the swig binary",
+        ),
+        "_swig": attr.label(
+            default = "@org_swig//:swig_stable",
+            allow_files = True,
+            cfg = "exec",
+        ),
+    },
+)

bazel/tcl_encode_or.bzl

@@ -19,9 +19,15 @@ def _tcl_encode_or_impl(ctx):
     args.add("--varname", ctx.attr.char_array_name)
     args.add("--namespace", ctx.attr.namespace)
 
+    # Only keep .tcl and .py files.
+    allowed_extensions = (".tcl", ".py")
+    filtered_sources = [
+        f for f in ctx.files.srcs if f.basename.endswith(allowed_extensions)
+    ]
+
     ctx.actions.run(
         outputs = [output_file],
-        inputs = ctx.files.srcs,
+        inputs = filtered_sources,
         arguments = [args],
         tools = [ctx.executable._encode_script],
         executable = ctx.toolchains["@rules_python//python:toolchain_type"].py3_runtime.interpreter,
@@ -44,7 +50,7 @@ tcl_encode = rule(
         ),
         "srcs": attr.label_list(
             allow_empty = False,
-            allow_files = [".tcl"],
+            allow_files = [".tcl", ".py"],
             doc = "Files to be wrapped.",
         ),
         "_encode_script": attr.label(