Merge branch 'master' of https://github.com/The-OpenROAD-Project/OpenROAD into grt_fill_via

Author: eder-matheus

BUILD.bazel

@@ -166,9 +166,6 @@ cc_binary(
         "src/Main.cc",
     ],
     copts = OPENROAD_COPTS,
-    data = [
-        "@tclreadline//:tclreadline_scripts",
-    ],
     features = ["-use_header_modules"],
     malloc = select({
         "@platforms//os:linux": "@tcmalloc//tcmalloc",
@@ -180,13 +177,13 @@ cc_binary(
         ":openroad_version",
         ":opt_notification",
         ":ord",
-        "//bazel:runfiles",
+        "//bazel:tcl_library_init",
+        "@rules_cc//cc/runfiles",  # sets BAZEL_CURRENT_REPOSITORY
         "//src/cut",
         "//src/gui",
         "//src/sta:opensta_lib",
         "//src/utl",
         "@boost.stacktrace",
-        "@rules_cc//cc/runfiles",
         "@tcl_lang//:tcl",
         # tclreadline: provides ENABLE_READLINE define + links libtclreadline.
         # On systems without tclreadline these are empty stub targets (no-op).

MODULE.bazel

@@ -15,6 +15,7 @@ bazel_dep(name = "platforms", version = "0.0.11")
 bazel_dep(name = "rules_bison", version = "0.3.1")
 bazel_dep(name = "rules_cc", version = "0.2.17")
 bazel_dep(name = "rules_flex", version = "0.3.1")
+bazel_dep(name = "rules_pkg", version = "1.2.0")
 bazel_dep(name = "rules_python", version = "1.8.5")
 bazel_dep(name = "rules_shell", version = "0.6.1")
 bazel_dep(name = "swig", version = "4.3.0.bcr.2")
@@ -65,6 +66,7 @@ bazel_dep(name = "or-tools", version = "9.15")
 bazel_dep(name = "readline", version = "8.2.bcr.3")
 bazel_dep(name = "spdlog", version = "1.15.1")
 bazel_dep(name = "tcl_lang", version = "8.6.16.bcr.1")
+bazel_dep(name = "tclreadline", version = "2.4.1")
 bazel_dep(name = "tcmalloc", version = "0.0.0-20250927-12f2552")
 bazel_dep(name = "yaml-cpp", version = "0.9.0")
 bazel_dep(name = "zlib", version = "1.3.1.bcr.5")
@@ -97,7 +99,6 @@ bazel_dep(name = "toolchains_llvm", version = "1.5.0")
 
 bazel_dep(name = "bant", version = "0.2.4", dev_dependency = True)
 bazel_dep(name = "googletest", version = "1.17.0.bcr.2", dev_dependency = True)
-bazel_dep(name = "rules_pkg", version = "1.2.0", dev_dependency = True)
 bazel_dep(name = "rules_verilator", version = "0.1.0", dev_dependency = True)
 bazel_dep(name = "verilator", version = "5.036.bcr.3", dev_dependency = True)
 
@@ -249,16 +250,6 @@ use_repo(maven, "maven")
 
 http_archive = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
-http_archive(
-    name = "tclreadline",
-    build_file = "//bazel:tclreadline.BUILD",
-    sha256 = "a64e0faed5957b8e1ac16f179948e21cdd6d3b8313590b7ab049a3192ab864fb",
-    strip_prefix = "tclreadline-2.3.8",
-    urls = [
-        "https://github.com/flightaware/tclreadline/archive/refs/tags/v2.3.8.tar.gz",
-    ],
-)
-
 http_archive(
     name = "circt",
     build_file_content = """

MODULE.bazel.lock

@@ -1,7 +1,12 @@
 load("@bazel_skylib//rules:build_test.bzl", "build_test")
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag")
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_pkg//pkg:mappings.bzl", "pkg_files", "strip_prefix")
+load("@rules_pkg//pkg:zip.bzl", "pkg_zip")
 load("@rules_python//python:pip.bzl", "compile_pip_requirements")
 load("@rules_python//python/entry_points:py_console_script_binary.bzl", "py_console_script_binary")
+load("//bazel:extract_zip.bzl", "extract_zip")
 
 package(features = ["layering_check"])
 
@@ -36,17 +41,99 @@ compile_pip_requirements(
     requirements_txt = "requirements_lock_3_13.txt",
 )
 
-cc_library(
-    name = "runfiles",
+# Various tcl libraries that we want to embed into the binary.
+pkg_files(
+    name = "tcl_core_files",
+    srcs = ["@tcl_lang//:tcl_core"],
+    strip_prefix = strip_prefix.from_root(),
+)
+
+pkg_files(
+    name = "tclreadline_files",
+    srcs = ["@tclreadline//:tclreadline_scripts"],
+    prefix = "tclreadline",
+    strip_prefix = strip_prefix.from_root(),
+)
+
+# Packaging up all tcl resources to one complete zip file. It can be
+# directly embedded in Tcl9 in a //zipfs:/ vfs.
+pkg_zip(
+    name = "tcl_resources_zip",
     srcs = [
-        "InitRunFiles.cpp",
-    ],
-    data = [
-        "@tcl_lang//:tcl_core",
+        ":tcl_core_files",
+        ":tclreadline_files",
     ],
+)
+
+# ... however, Tcl8 still needs access to a directory, so unpack in that case.
+extract_zip(
+    name = "tcl_resources_dir",
+    src = ":tcl_resources_zip",
+)
+
+genrule(
+    name = "tcl_resources_zip_data_h",
+    srcs = [":tcl_resources_zip"],
+    outs = ["tcl_resources_zip_data.h"],
+    cmd = "$(location :embed) kTclResourceZip $< $@",
+    tools = [":embed"],
+)
+
+cc_binary(
+    name = "embed",
+    srcs = ["embed.cc"],
+)
+
+# As long as we support tcl8 (using runfiles) we need this flag.
+bool_flag(
+    name = "use_zipfs",
+    build_setting_default = False,  # False until we can use tcl9
+)
+
+config_setting(
+    name = "zipfs_config",
+    flag_values = {":use_zipfs": "true"},
+)
+
+# Library initialization is a bit different for tcl8 and tcl9.
+# In tcl9, we can use a zipped version of the needed include files, but
+# for tcl8, we have to use the unpacked zip file and point our runfiles
+# to it.
+cc_library(
+    name = "tcl_library_init",
+    srcs = ["tcl_library_init.cc"] +
+           select({
+               ":zipfs_config": ["tcl_resources_zip_data.h"],
+               "//conditions:default": [],
+           }),
+    hdrs = ["tcl_library_init.h"],
+    copts = select({
+        ":zipfs_config": [],
+        "//conditions:default": ["-DUSE_TCL_RUNFILE_INIT"],
+    }),
+    data = select({
+        ":zipfs_config": [],
+        "//conditions:default": [":tcl_resources_dir"],
+    }),
+    visibility = ["//visibility:public"],
+    deps = [
+        "@tcl_lang//:tcl",
+    ] + select({
+        ":zipfs_config": [],
+        "//conditions:default": ["@rules_cc//cc/runfiles"],
+    }),
+)
+
+# shim old library as it is still referenced in src/sta, implementing the
+# old behavior.
+cc_library(
+    name = "runfiles",
+    srcs = ["InitRunFiles.cpp"],
+    data = [":tcl_resources_dir"],
     visibility = ["//visibility:public"],
     deps = [
         "@rules_cc//cc/runfiles",
+        "@tcl_lang//:tcl",
     ],
     alwayslink = True,
 )

bazel/BUILD

@@ -1,11 +1,19 @@
-#include <unistd.h>
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2026, The OpenROAD Authors
+
+// This file to go away as soon as we use the tcl_library_init initialization
+// in OpenSTA.
+
+#include <unistd.h>  // readlink()
 
 #include <climits>
 #include <cstdlib>
+#include <filesystem>
 #include <iostream>
 #include <memory>
 #include <optional>
 #include <string>
+#include <system_error>
 
 #if defined(__APPLE__)
 #include <mach-o/dyld.h>
@@ -14,9 +22,10 @@
 
 #include "rules_cc/cc/runfiles/runfiles.h"
 
+namespace {
 // Avoid adding any dependencies like boost.filesystem
 // Returns path to running binary if possible, otherwise nullopt.
-static std::optional<std::string> getProgramLocation()
+static std::optional<std::string> GetProgramLocation()
 {
 #if defined(_WIN32)
   char result[MAX_PATH + 1] = {'\0'};
@@ -37,41 +46,41 @@ static std::optional<std::string> getProgramLocation()
   return std::nullopt;
 }
 
-// Global constructor class to initialize Bazel runfiles and environment
-// variables
+std::string GetTclLibraryBaseLocation()
+{
+  using rules_cc::cc::runfiles::Runfiles;
+  std::string error;
+  std::unique_ptr<Runfiles> runfiles(Runfiles::Create(
+      *GetProgramLocation(), BAZEL_CURRENT_REPOSITORY, &error));
+  if (!runfiles) {
+    std::cerr << "[Warning] Failed to create bazel runfiles: " << error << "\n";
+    return "";
+  }
+
+  std::error_code ec;
+  for (const std::string loc : {"openroad", "opensta", "_main"}) {
+    const std::string check_loc = loc + "/bazel/tcl_resources_dir";
+    const std::string path = runfiles->Rlocation(check_loc);
+    if (!path.empty() && std::filesystem::exists(path, ec)) {
+      return path;
+    }
+  }
+  return "";
+}
+
 class BazelInitializer
 {
  public:
   BazelInitializer()
   {
-    using rules_cc::cc::runfiles::Runfiles;
-
-    std::string error;
-    std::string program_location = getProgramLocation().value();
-    std::unique_ptr<Runfiles> runfiles(
-        Runfiles::Create(program_location, BAZEL_CURRENT_REPOSITORY, &error));
-    if (!runfiles) {
-      std::cerr << "Error initializing Bazel runfiles: " << error << std::endl;
-      std::exit(1);
-    }
-
-    // Set the TCL_LIBRARY environment variable
-    const std::string tcl_path = runfiles->Rlocation("tcl_lang/library/");
-    if (!tcl_path.empty()) {
+    const std::string lib_mount_point = GetTclLibraryBaseLocation();
+    if (!lib_mount_point.empty()) {
+      const std::string tcl_path = lib_mount_point + "/library";
       setenv("TCL_LIBRARY", tcl_path.c_str(), true);
-    } else {
-      std::cerr << "Error: Could not locate 'tcl_lang/library/' in runfiles."
-                << std::endl;
-      std::exit(1);
     }
-
-    // Setup env variables for any other libraries that use runfiles
-    std::string manifest = program_location + ".runfiles/MANIFEST";
-    std::string runfiles_dir = program_location + ".runfiles";
-    setenv("RUNFILES_MANIFEST_FILE", manifest.c_str(), /*__replace=*/true);
-    setenv("RUNFILES_DIR", runfiles_dir.c_str(), /*__replace=*/true);
   }
 };
 
-// Instantiate the global constructor
+// Provide via global constructor.
 static BazelInitializer bazel_initializer;
+}  // namespace

bazel/InitRunFiles.cpp

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2026, The OpenROAD Authors
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
+int main(int argc, char* argv[])
+{
+  if (argc != 4) {
+    fprintf(stderr,
+            "Usage: %s <variable-name> <input-file> <output_file>\n",
+            argv[0]);
+    return 1;
+  }
+
+  const char* variable_name = argv[1];
+  const char* input_file = argv[2];
+  const char* output_file = argv[3];
+
+  FILE* in_file = fopen(input_file, "rb");
+  if (!in_file) {
+    perror("Could not open input.");
+    return EXIT_FAILURE;
+  }
+
+  FILE* out_file = fopen(output_file, "wb");
+  if (!out_file) {
+    fclose(in_file);
+    perror("Could not open output.");
+    return EXIT_FAILURE;
+  }
+
+  fprintf(out_file,
+          "static inline constexpr unsigned char %s[] = {\n  ",
+          variable_name);
+  uint8_t buffer[100 * 12];
+  size_t nread;
+  while ((nread = fread(buffer, 1, sizeof(buffer), in_file)) > 0) {
+    for (int i = 0; i < nread; ++i) {
+      fprintf(out_file, "0x%02x,%s", buffer[i], i % 12 == 11 ? "\n  " : " ");
+    }
+  }
+  const bool any_issue = ferror(in_file) || ferror(out_file);
+  if (any_issue) {
+    perror("trouble reading file.");
+  }
+  fprintf(out_file, "};\n");
+  fclose(in_file);
+  fclose(out_file);
+
+  return any_issue ? EXIT_FAILURE : EXIT_SUCCESS;
+}

bazel/embed.cc

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2026, The OpenROAD Authors
+
+# We need this rule as long as we support Tcl 8
+
+"""
+Unzip a zip file into a directory.
+
+Since this creates a directory, we need to have it as separate rule
+and can't just have a genrule().
+"""
+
+def _extract_zip_impl(ctx):
+    out_dir = ctx.actions.declare_directory(ctx.attr.name)
+    ctx.actions.run(
+        inputs = [ctx.file.src],
+        outputs = [out_dir],
+        executable = ctx.executable._zipper,
+        arguments = ["x", ctx.file.src.path, "-d", out_dir.path],
+    )
+    return [DefaultInfo(
+        files = depset([out_dir]),
+        runfiles = ctx.runfiles(files = [out_dir]),
+    )]
+
+extract_zip = rule(
+    implementation = _extract_zip_impl,
+    attrs = {
+        "src": attr.label(allow_single_file = [".zip", ".jar"]),
+        "_zipper": attr.label(
+            default = Label("@bazel_tools//tools/zip:zipper"),
+            cfg = "exec",
+            executable = True,
+        ),
+    },
+)