deps: pin yosys 0.63 + carry bazel-orfs BLOCKS shared-block.mk patch

Two coupled MODULE.bazel changes:

1. single_version_override(yosys = "0.63").  bazel-orfs pins
   yosys 0.62.bcr.2, which has a KOGGE_STONE / BRENT_KUNG IdString
   memory-safety bug that crashes synth on a few asap7 designs.
   0.63 is on canonical BCR; drop this override once bazel-orfs itself
   bumps to 0.63.

2. git_override(patches = [.../0001-blocks-shared-blockmk.patch]) on
   the bazel-orfs dep.  bazel-orfs's BLOCKS handling only walks
   per-block sub-directory configs (<design>/<block>/config.mk).
   Make's flow/Makefile GENERATE_ABSTRACT_RULE has a second branch:
   when there's no per-block config.mk, fall back to a shared
   block.mk parameterised by DESIGN_NAME=<block> and
   DESIGN_NICKNAME=<parent>_<block>.

   flow/designs/asap7/aes-block is the canonical example: it sets
   BLOCKS=aes_rcon aes_sbox but the blocks share aes-block/block.mk
   rather than each owning a sub-dir config.  Before this patch the
   parser recorded result.blocks but left result.block_configs empty;
   designs.bzl then never added asap7/aes-block_aes_rcon /
   asap7/aes-block_aes_sbox entries to DESIGNS;
   _create_block_targets looked them up by composite key, got None,
   and silently skipped.  The parent's synth_odb action ran without
   the sub-block .lef/.lib abstracts and the resulting .odb omitted
   the two abstract cells (bazel's 1_synth.odb header byte at offset
   16 = 212 cells vs make's 214).

   Patch carried locally; will be upstreamed.  Two changes:

   - config_mk_parser.parse() takes an overrides= arg that pins
     DESIGN_NAME / DESIGN_NICKNAME after file parsing.  BLOCKS
     post-processing falls back to shared block.mk and calls
     parse() with the appropriate overrides.
   - _path_to_label strips a leading "./" before label conversion so
     block.mk-style relative paths (e.g.
     ./designs/asap7/aes/constraint.sdc) don't become malformed
     labels (//./designs/asap7/aes:foo.sdc).

   Verified on asap7/aes-block: bazel's 1_synth.odb cell-count byte
   now matches make's (0xd6 = 214) — sub-block abstracts are read
   into the parent synth_odb action.

MODULE.bazel.lock reflects the yosys 0.62.bcr.2 → 0.63 swap; no other
modules move.

Signed-off-by: Øyvind Harboe <oyvind.harboe@zylin.com>

Author: oharboe

MODULE.bazel

@@ -10,6 +10,15 @@ module(
 bazel_dep(name = "rules_python", version = "1.8.5")
 bazel_dep(name = "rules_shell", version = "0.6.1")
 
+# Override bazel-orfs's yosys 0.62.bcr.2 pin to 0.63 — 0.62 has a
+# KOGGE_STONE / BRENT_KUNG IdString memory-safety bug that breaks synth
+# on a few asap7 designs.  0.63 is on BCR; remove this once bazel-orfs
+# itself bumps to 0.63.
+single_version_override(
+    module_name = "yosys",
+    version = "0.63",
+)
+
 # --- Dev dependencies (only honoured when @orfs is the root module) ---
 #
 # When @orfs is consumed as a non-root dep (e.g. by tools/OpenROAD), the
@@ -20,7 +29,6 @@ bazel_dep(name = "rules_shell", version = "0.6.1")
 # time.
 
 bazel_dep(name = "toolchains_llvm", version = "1.5.0", dev_dependency = True)
-
 bazel_dep(name = "openroad", dev_dependency = True)
 local_path_override(
     module_name = "openroad",
@@ -45,6 +53,10 @@ BAZEL_ORFS_REMOTE = "https://github.com/The-OpenROAD-Project/bazel-orfs.git"
 git_override(
     module_name = "bazel-orfs",
     commit = BAZEL_ORFS_COMMIT,
+    patch_strip = 1,
+    patches = [
+        "//bazel/bazel-orfs-patches:0001-blocks-shared-blockmk.patch",
+    ],
     remote = BAZEL_ORFS_REMOTE,
 )
 
@@ -79,7 +91,10 @@ llvm.toolchain(
 )
 use_repo(llvm, "llvm_toolchain")
 
-register_toolchains("@llvm_toolchain//:all", dev_dependency = True)
+register_toolchains(
+    "@llvm_toolchain//:all",
+    dev_dependency = True,
+)
 
 python = use_extension("@rules_python//python/extensions:python.bzl", "python")
 python.toolchain(

MODULE.bazel.lock

@@ -0,0 +1,119 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?=C3=98yvind=20Harboe?= <oyvind@ascenium.com>
+Date: Wed, 14 May 2026 12:00:00 +0200
+Subject: [PATCH] config_mk_parser: handle shared block.mk for BLOCKS=
+
+bazel-orfs's BLOCKS handling only walks per-block sub-directory
+configs (`<design>/<block>/config.mk`).  Make's flow/Makefile
+GENERATE_ABSTRACT_RULE has a second branch: when there is no per-block
+config.mk, fall back to a shared `block.mk` parameterised by
+DESIGN_NAME=<block> and DESIGN_NICKNAME=<parent>_<block>.
+
+`flow/designs/asap7/aes-block` is the canonical example: it sets
+`BLOCKS=aes_rcon aes_sbox` but the blocks share `aes-block/block.mk`
+rather than each owning a sub-dir config.  Today the parser records
+`result.blocks = ["aes_rcon", "aes_sbox"]` but leaves
+`result.block_configs` empty; the `orfs_designs` repo rule then never
+adds `asap7/aes-block_aes_rcon` / `..._aes_sbox` entries to DESIGNS;
+`_create_block_targets` looks them up by composite key, gets `None`,
+and silently skips.  The parent's synth_odb action then runs without
+the sub-block .lef/.lib abstracts and the resulting .odb omits the two
+abstract cells (bazel's 1_synth.odb header byte at offset 16 = 212
+cells vs make's 214).
+
+Mirror the make-side fallback in the parser:
+
+- Add an `overrides=` arg to parse() that pins DESIGN_NAME and
+  DESIGN_NICKNAME after file parsing finishes.
+- In the BLOCKS post-processing, fall back to shared block.mk when
+  no per-block sub-dir config exists.
+- Normalize leading "./" in _path_to_label so block.mk-style relative
+  paths like `./designs/asap7/aes/constraint.sdc` don't become
+  malformed labels (`//./designs/asap7/aes:constraint.sdc`).
+
+`private/designs.bzl` already promotes each block_config to a DESIGNS
+entry keyed by `<platform>/<design_nickname>`, so once the parser
+populates block_configs the rest of the wiring works.
+
+Signed-off-by: =?UTF-8?q?=C3=98yvind=20Harboe?= <oyvind@ascenium.com>
+---
+ config_mk_parser.py | 47 ++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 46 insertions(+), 1 deletion(-)
+
+--- a/config_mk_parser.py
++++ b/config_mk_parser.py
+@@ -156,7 +156,7 @@
+         self.designs_home = designs_home
+         self.flow_home = flow_home
+ 
+-    def parse(self, config_path, base_dir=None):
++    def parse(self, config_path, base_dir=None, overrides=None):
+         """Parse a config.mk file and return a ParsedDesign.
+ 
+         Args:
+@@ -221,6 +221,16 @@
+         elif result.design_name:
+             result.design_nickname = result.design_name
+ 
++        # Apply caller-supplied overrides to structural vars.  Used by
++        # the shared-block.mk BLOCKS path below to parameterise the
++        # same block.mk for each entry of BLOCKS=, mirroring make's
++        # flow/Makefile GENERATE_ABSTRACT_RULE second branch.
++        if overrides:
++            if "DESIGN_NAME" in overrides:
++                result.design_name = overrides["DESIGN_NAME"]
++            if "DESIGN_NICKNAME" in overrides:
++                result.design_nickname = overrides["DESIGN_NICKNAME"]
++
+         # Check structural vars for deprecated patterns
+         for var_name in ("DESIGN_NICKNAME", "DESIGN_NAME", "PLATFORM"):
+             if var_name in raw_vars:
+@@ -277,14 +287,34 @@
+             elif var_name not in NON_ARGUMENT_VARS:
+                 result.arguments[var_name] = resolved
+ 
+-        # Process BLOCKS — discover and parse sub-macro configs
++        # Process BLOCKS — discover and parse sub-macro configs.
+         if result.blocks:
+             config_dir = os.path.dirname(config_path)
++            shared_block_mk = os.path.join(config_dir, "block.mk")
+             for block_name in result.blocks:
++                # Path 1: per-block config.mk in a sub-directory.
+                 block_config = os.path.join(config_dir, block_name, "config.mk")
+                 if os.path.exists(block_config):
+                     block_parsed = self.parse(block_config)
+                     result.block_configs.append(block_parsed)
++                    continue
++                # Path 2: shared block.mk parameterised by DESIGN_NAME.
++                # Matches make's flow/Makefile GENERATE_ABSTRACT_RULE
++                # second branch:
++                #     $(MAKE) DESIGN_NAME=<block> \
++                #             DESIGN_NICKNAME=<parent>_<block> \
++                #             DESIGN_CONFIG=<parent_dir>/block.mk \
++                #             generate_abstract
++                if os.path.exists(shared_block_mk):
++                    block_parsed = self.parse(
++                        shared_block_mk,
++                        overrides={
++                            "DESIGN_NAME": block_name,
++                            "DESIGN_NICKNAME":
++                                f"{result.design_nickname}_{block_name}",
++                        },
++                    )
++                    result.block_configs.append(block_parsed)
+ 
+         return result
+ 
+@@ -812,6 +842,12 @@
+         if not path:
+             return path
+ 
++        # Normalize leading "./" — block.mk-style relative paths
++        # (e.g. ./designs/asap7/aes/constraint.sdc).  Without this
++        # they become malformed labels like //./designs/asap7/aes:foo.
++        while path.startswith("./"):
++            path = path[2:]
++
+         # Already a label
+         if path.startswith("//") or path.startswith("@"):
+             return path

bazel/bazel-orfs-patches/0001-blocks-shared-blockmk.patch

@@ -0,0 +1 @@
+exports_files(glob(["*.patch"]))