build: fetch and pin the HRX toolchain under the tree, not /opt/rocm-therock (#713)

.gitignore

@@ -26,3 +26,7 @@ __pycache__/
 
 # ctest run in the source tree (kept out of the PR by the copyright check)
 Testing/
+
+# the HRX toolchain the build fetches (scripts/fetch-rocm-sdk.sh, config/hrx-toolchain.config):
+# a multi-gigabyte venv of TheRock's ROCm SDK at the pinned version, not part of the source
+third_party/toolchain/

CMakeLists.txt

@@ -160,6 +160,10 @@ add_test(NAME release_check_row COMMAND ${CMAKE_SOURCE_DIR}/os/mini/release-chec
 # dir, so no key, no device and no build: the four refusals are a set with no manifest, a file the
 # manifest does not list, a ciphertext byte flipped after signing, and a manifest signed by another key.
 add_test(NAME seal_manifest COMMAND ${CMAKE_SOURCE_DIR}/tests/seal_manifest_test.sh)
+# engine #713: the pinned HRX toolchain (config/hrx-toolchain.config, scripts/fetch-rocm-sdk.sh) -- the
+# pin file's refusals, the completeness check against a fabricated tree, and that cmake, build-ds4.sh and
+# weekly.sh all use the pin instead of the box's /opt/rocm-therock. No network, no SDK, no GPU.
+add_test(NAME hrx_toolchain_pin COMMAND ${CMAKE_SOURCE_DIR}/tests/hrx_toolchain_pin.sh)
 add_test(NAME pm_route COMMAND ${CMAKE_SOURCE_DIR}/tests/pm_route.sh $<TARGET_FILE:onebit>)
 add_test(NAME bench_selftest COMMAND ${CMAKE_SOURCE_DIR}/tests/bench_selftest.sh $<TARGET_FILE:onebit>)
 add_test(NAME prism_route COMMAND ${CMAKE_SOURCE_DIR}/tests/prism_route.sh $<TARGET_FILE:onebit>)

cmake/hrx.cmake

@@ -32,7 +32,41 @@
 # branch name still says "vulkan" (AMD's pair carried both); the engine no longer builds it.
 include(ExternalProject)
 
-set(ONEBIT_HRX_TOOLCHAIN "/opt/rocm-therock" CACHE PATH "ROCm/TheRock root: its amdclang builds llama.cpp and HRX")
+# The toolchain (docs/hrx.md, "The toolchain"; engine#713): the pinned copy under the tree first,
+# because the build must need nothing outside the repository (scripts/fetch-rocm-sdk.sh fills it at
+# the pin config/hrx-toolchain.config names), then the box's TheRock, then a distro ROCm.
+# The tree copy is resolved from the pin itself, version and target, not from a glob: a glob takes
+# whatever sorts first, so after a version bump the old SDK would win silently (pi-prs's review of
+# #771). -DONEBIT_HRX_TOOLCHAIN=<dir>, or ROCM_PATH through the build scripts, overrides all three.
+if(NOT ONEBIT_HRX_TOOLCHAIN)
+    set(_hrx_toolchain_pinned "")
+    set(_hrx_pin "${CMAKE_SOURCE_DIR}/config/hrx-toolchain.config")
+    if(EXISTS "${_hrx_pin}")
+        file(STRINGS "${_hrx_pin}" _hrx_ver REGEX "^version=")
+        file(STRINGS "${_hrx_pin}" _hrx_gfx REGEX "^gfx=")
+        list(LENGTH _hrx_ver _hrx_ver_n)
+        list(LENGTH _hrx_gfx _hrx_gfx_n)
+        if(_hrx_ver_n GREATER 0 AND _hrx_gfx_n GREATER 0)
+            list(GET _hrx_ver 0 _hrx_ver)
+            list(GET _hrx_gfx 0 _hrx_gfx)
+            string(REPLACE "version=" "" _hrx_ver "${_hrx_ver}")
+            string(REPLACE "gfx=" "" _hrx_gfx "${_hrx_gfx}")
+            set(_hrx_pinned_dir "${CMAKE_SOURCE_DIR}/third_party/toolchain/rocm-sdk-${_hrx_ver}-${_hrx_gfx}")
+            if(EXISTS "${_hrx_pinned_dir}/bin/amdclang")
+                set(_hrx_toolchain_pinned "${_hrx_pinned_dir}")
+            endif()
+        endif()
+    endif()
+    if(_hrx_toolchain_pinned)
+        set(_hrx_toolchain_default "${_hrx_toolchain_pinned}")
+    elseif(EXISTS "/opt/rocm-therock")
+        set(_hrx_toolchain_default "/opt/rocm-therock")
+    else()
+        set(_hrx_toolchain_default "/opt/rocm")
+    endif()
+    set(ONEBIT_HRX_TOOLCHAIN "${_hrx_toolchain_default}" CACHE PATH "ROCm/TheRock root: its amdclang builds llama.cpp and HRX")
+endif()
+message(STATUS "ONEBIT_HRX: toolchain ${ONEBIT_HRX_TOOLCHAIN}")
 
 # The HRX binaries carry strings from this tree and, with -DONEBIT_GPU_PRIVATE, from the add-on
 # checkout; both are rewritten so the shipped libraries name no build-machine path.
@@ -41,6 +75,8 @@ set(ONEBIT_HRX_PATH_MAP_FLAGS "-ffile-prefix-map=${CMAKE_SOURCE_DIR}=."
 if(ONEBIT_GPU_PRIVATE)
     string(APPEND ONEBIT_HRX_PATH_MAP_FLAGS " -ffile-prefix-map=${ONEBIT_GPU_PRIVATE}=addon")
 endif()
+# Flags the HRX llama.cpp build needs from this toolchain, kept apart from the path maps above.
+set(ONEBIT_HRX_EXTRA_FLAGS "")
 
 # A source build outside the org has no private HIP kernels to compile, so it links the prebuilt
 # HRX tree from the public binary drop instead (docs/releases.md, "The public binary drop"): the
@@ -96,6 +132,45 @@ endif()
 set(ONEBIT_HRX_LIBHSA "${_hrx_libhsa_first}" CACHE FILEPATH "TheRock HSA runtime HRX loads (IREE_HAL_AMDGPU_LIBHSA_PATH)")
 message(STATUS "ONEBIT_HRX: HSA runtime ${ONEBIT_HRX_LIBHSA}")
 
+# The device library (the amdgcn bitcode hipcc links for --offload-arch) sits inside the SDK's pip
+# tree, not under <root>/lib (the 2026-10-31 rebuild): without this flag every HIP step dies with
+# "cannot find ROCm device library: provide its path via '--rocm-path' or '--rocm-device-lib-path'".
+# Read from the toolchain itself, so the build needs no HIP_DEVICE_LIB_PATH / ROCM_PATH / HIP_PATH,
+# which is what engine#713 is for. A toolchain without one builds on hipcc's own default.
+set(ONEBIT_HRX_DEVICE_LIB "" CACHE FILEPATH "gfx device library (amdgcn bitcode) hipcc links against")
+set(_hrx_sdk_core "")
+if(NOT ONEBIT_HRX_DEVICE_LIB)
+    file(GLOB _hrx_sdk_cores "${ONEBIT_HRX_TOOLCHAIN}/lib/python3*/site-packages/_rocm_sdk_core")
+    if(_hrx_sdk_cores)
+        list(GET _hrx_sdk_cores 0 _hrx_sdk_core)
+        if(EXISTS "${_hrx_sdk_core}/lib/llvm/amdgcn/bitcode")
+            set(ONEBIT_HRX_DEVICE_LIB "${_hrx_sdk_core}/lib/llvm/amdgcn/bitcode" CACHE FILEPATH
+                "gfx device library (amdgcn bitcode) hipcc links against" FORCE)
+        endif()
+    endif()
+endif()
+if(ONEBIT_HRX_DEVICE_LIB)
+    string(APPEND ONEBIT_HRX_EXTRA_FLAGS " --rocm-device-lib-path=${ONEBIT_HRX_DEVICE_LIB}")
+    message(STATUS "ONEBIT_HRX: device library ${ONEBIT_HRX_DEVICE_LIB}")
+else()
+    message(STATUS "ONEBIT_HRX: no device library under ${ONEBIT_HRX_TOOLCHAIN}; hipcc's default is used")
+endif()
+# The private HIP kernels are compiled by a separate amdclang++ invocation (ggml-hrx-hip.cmake), not by
+# hipcc, and it does not inherit the flags above: without GGML_HRX_HIP_FLAGS the device library has to come
+# from HIP_DEVICE_LIB_PATH in the environment. Pass the compiler from this toolchain (its own find_program
+# would otherwise take /opt/rocm-therock/bin before $ROCM_PATH) and the same device library in the flags.
+set(_hrx_hip_flags "-O3")
+if(ONEBIT_HRX_DEVICE_LIB)
+    string(APPEND _hrx_hip_flags " --rocm-device-lib-path=${ONEBIT_HRX_DEVICE_LIB}")
+endif()
+set(ONEBIT_HRX_HIP_COMPILER "${ONEBIT_HRX_TOOLCHAIN}/bin/amdclang++" CACHE FILEPATH
+    "amdclang++ that compiles the HRX HIP kernels")
+set(ONEBIT_HRX_HIP_FLAGS "${_hrx_hip_flags}" CACHE STRING "Extra flags for the HRX HIP kernels")
+set(_hrx_toolchain_env)
+if(_hrx_sdk_core)
+    set(_hrx_toolchain_env ${CMAKE_COMMAND} -E env "ROCM_PATH=${_hrx_sdk_core}" "HIP_PATH=${_hrx_sdk_core}")
+endif()
+
 # Private GPU kernels (docs/hrx.md, "Private HIP kernels"): a checkout of the private add-on
 # repository whose addons/hip-hrx is built into the HRX llama.cpp (its GGML_HRX_HIP_ADDON_DIR hook).
 set(_hrx_gpu_private_args)
@@ -139,11 +214,13 @@ ExternalProject_Add(llama_hrx
         -DCMAKE_CXX_COMPILER=${ONEBIT_HRX_TOOLCHAIN}/bin/amdclang++
         -DHRX_SOURCE_DIR=${CMAKE_SOURCE_DIR}/third_party/hrx-system
         -DGGML_HRX=ON -DGGML_VULKAN=OFF -DGGML_CUDA=OFF -DGGML_HIP=OFF -DGGML_NATIVE=ON -DGGML_CPU=ON
+        -DGGML_HRX_HIP_COMPILER=${ONEBIT_HRX_HIP_COMPILER}
+        "-DGGML_HRX_HIP_FLAGS=${ONEBIT_HRX_HIP_FLAGS}"
         -DLLAMA_BUILD_SERVER=ON -DLLAMA_CURL=OFF
-        "-DCMAKE_C_FLAGS=${ONEBIT_HRX_PATH_MAP_FLAGS}"
-        "-DCMAKE_CXX_FLAGS=${ONEBIT_HRX_PATH_MAP_FLAGS}"
+        "-DCMAKE_C_FLAGS=${ONEBIT_HRX_PATH_MAP_FLAGS}${ONEBIT_HRX_EXTRA_FLAGS}"
+        "-DCMAKE_CXX_FLAGS=${ONEBIT_HRX_PATH_MAP_FLAGS}${ONEBIT_HRX_EXTRA_FLAGS}"
         ${_hrx_gpu_private_args}
-    BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --target llama-server llama-bench llama-perplexity
+    BUILD_COMMAND ${_hrx_toolchain_env} ${CMAKE_COMMAND} --build <BINARY_DIR> --target llama-server llama-bench llama-perplexity
     INSTALL_COMMAND ""
     BUILD_ALWAYS ON
     USES_TERMINAL_BUILD ON)

config/hrx-toolchain.config

@@ -0,0 +1,30 @@
+# Copyright 2026 bong-water-water-bong
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# The HRX toolchain the build compiles with (docs/hrx.md, "The toolchain"; docs/releases.md,
+# "What is in a release"): TheRock's ROCm SDK at one nightly version, for one GPU target, fetched
+# by scripts/fetch-rocm-sdk.sh into third_party/toolchain/rocm-sdk-<version>-<gfx>. It is pinned
+# like every other upstream (hrx-system, llama.cpp, the kernel and runtime pins) so that a fresh
+# box needs only this repository: nothing outside it, and no HIP_DEVICE_LIB_PATH / ROCM_PATH /
+# HIP_PATH, is required to build. cmake/hrx.cmake and scripts/build-ds4.sh default to the fetched
+# copy; /opt/rocm-therock stays an override (ROCM_PATH or -DONEBIT_HRX_TOOLCHAIN=<dir>).
+#
+# Move the pin by hand, after the HRX checks on Strix Halo (docs/hrx.md, "Checking HRX"). The
+# version is a nightly wheel version from the index below, and the gfx target is what
+# --offload-arch builds; it is the same target the box has.
+version=10.3.0a20261031
+gfx=gfx1151
+index=https://nightly.repo.amd.com/rocm/whl-next/
+require=bin/amdclang bin/hipcc bin/hipconfig

docs/dwarfstar.md

@@ -58,7 +58,8 @@ stays clean) and puts `ds4-server`, `ds4` and `ds4-bench` in `<prefix>/hip`.
 `DS4_TEST=1` then runs DwarfStar's model-free routed-MoE test on the GPU.
 
 **HIP (Strix Halo)** needs HIP, hipBLAS, hipBLASLt, rocBLAS, rocWMMA and hipCUB. The
-script takes `ROCM_PATH`, else TheRock's SDK
+script takes `ROCM_PATH`, else the pinned toolchain under `third_party/toolchain`
+(`scripts/fetch-rocm-sdk.sh`, [hrx.md](hrx.md) "The toolchain"), else TheRock's SDK
 (`/opt/rocm-therock/lib/python3*/site-packages/_rocm_sdk_devel`), else `/opt/rocm`.
 It passes that SDK's `include/` with `-isystem`: clang otherwise searches it after
 `/usr/include`, and a distro HIP there (another version) shadows TheRock's headers

docs/hrx.md

@@ -870,11 +870,21 @@ table: 16 f16 inputs and 4 f32 results per lane in wave64.
 ## Build
 
 ```bash
+scripts/fetch-rocm-sdk.sh                      # the pinned toolchain, into third_party/toolchain/
 git submodule update --init --depth 1 third_party/hrx-system third_party/llama.cpp
-cmake -B build -G Ninja -DONEBIT_HRX=ON          # needs TheRock at /opt/rocm-therock (ONEBIT_HRX_TOOLCHAIN)
+cmake -B build -G Ninja -DONEBIT_HRX=ON          # -DONEBIT_HRX_TOOLCHAIN=<dir> overrides the toolchain
 cmake --build build --target onebit
 ```
 
+- **The toolchain.** The build compiles with TheRock's ROCm SDK at one pinned version and one GPU
+  target, `config/hrx-toolchain.config` (engine#713): `scripts/fetch-rocm-sdk.sh` installs
+  `rocm[libraries,devel,device-gfx1151]` at that version from the nightly wheel index into
+  `third_party/toolchain/rocm-sdk-<version>-<gfx>`, and `cmake/hrx.cmake` defaults to that copy, so
+  a fresh box needs only this repository. `-DONEBIT_HRX_TOOLCHAIN` / `ROCM_PATH` still override it,
+  and an existing `/opt/rocm-therock` is used when the tree copy is absent. The device library
+  (the `amdgcn` bitcode) is read from the toolchain itself, so no `HIP_DEVICE_LIB_PATH`,
+  `ROCM_PATH` or `HIP_PATH` is needed in the environment.
+
 - **One external project.** llama.cpp's ggml-hrx builds hrx-system itself
   (`HRX_SOURCE_DIR`) with TheRock's `amdclang`.
 - **HRX0 and the CPU only.** `GGML_VULKAN`, `GGML_HIP` and `GGML_CUDA` are off. The targets are
@@ -890,7 +900,7 @@ cmake --build build --target onebit
   gfx1151, so HRX then registers no device. CMake finds TheRock's
   `libhsa-runtime64.so.1` (`ONEBIT_HRX_LIBHSA`), and `1bit serve` passes it to
   llama-server as `IREE_HAL_AMDGPU_LIBHSA_PATH`, unless it is already set. Without a
-  build path it searches `/opt/rocm-therock`. To run
+  build path it searches the pinned toolchain, then `/opt/rocm-therock`. To run
   llama-server or llama-bench by hand, export that variable yourself.
 
 ### Private HIP kernels

docs/releases.md

@@ -52,6 +52,7 @@ Qwen3.8-Flash-Next run on **HRX** here, and the catalogue carries no `ds4` recip
 | engine | `bcb28cc8f57387865ecdbe744a7e3cdcf65eb7ad` |
 | HRX (llama.cpp fork, ggml-hrx) | `4a58da9b087d` |
 | hrx-system | `82804197bcbe` |
+| HRX toolchain (ROCm/TheRock SDK) | `10.3.0a20261031`, `gfx1151` (`config/hrx-toolchain.config`) |
 | Lemonade Server | `2026.46.0~1.ef0f3b49` (our fork, the `onebit` recipe) |
 | kernel in the image | `7.3.0-rc4-1bit-perfopt` (IOMMU PerfOpt backports, MOK-signed) |
 | NPU kernel sets | 3 sealed sets, 30 kernels, every manifest signed |
@@ -233,8 +234,9 @@ tar --zstd -xf lemonade-onebit-v2026.40-linux-x86_64.tar.zst
 lemonade-onebit-v2026.40/lemond-onebit           # lemond with the onebit recipe on the packaged engine
 ```
 
-The builds target Strix Halo: the llama.cpp backends are built with `GGML_NATIVE` on its Zen 5. HRX needs TheRock in
-`/opt/rocm-therock`; the NPU needs the `amdxdna` kernel driver. The closed NPU add-ons
+The builds target Strix Halo: the llama.cpp backends are built with `GGML_NATIVE` on its Zen 5. HRX builds with the
+pinned toolchain (`config/hrx-toolchain.config`, `scripts/fetch-rocm-sdk.sh`), or TheRock in `/opt/rocm-therock` when
+that is what the box has; the NPU needs the `amdxdna` kernel driver. The closed NPU add-ons
 ([npu.md](npu.md#add-on-routes)) are never in a release.
 
 ### The NPU engine
@@ -380,8 +382,10 @@ WEEKLY_DRY_RUN=1 WEEKLY_TAG=rehearsal-private scripts/weekly.sh ~/.cache/1bit-we
 Before the first stage runs, `weekly.sh` checks what the machine must have (the 2026-10-19
 rehearsal found these only after the build) and stops with a message naming what is missing:
 
-- **bumps, build:** TheRock in `/opt/rocm-therock`, or `-DONEBIT_HRX_TOOLCHAIN=<dir>` in
-  `WEEKLY_CMAKE_ARGS`; `hipcc` only for the optional DwarfStar build (`ONEBIT_DS4=ON`, off since v2026.44), in TheRock or `/opt/rocm`, or `ROCM_PATH`.
+- **bumps, build:** the pinned HRX toolchain, which `preflight` itself fetches with
+  `scripts/fetch-rocm-sdk.sh` at the pin in `config/hrx-toolchain.config` (`-DONEBIT_HRX_TOOLCHAIN=<dir>` in
+  `WEEKLY_CMAKE_ARGS` uses another, e.g. TheRock in `/opt/rocm-therock`); `hipcc` only for the optional DwarfStar build
+  (`ONEBIT_DS4=ON`, off since v2026.44), from that toolchain or `/opt/rocm`, or `ROCM_PATH`.
 - **package:** `patchelf` (`scripts/package-linux.sh`); `node` and `npm` for Lemonade's web app
   (`LEMONADE_WEB_APP=1 scripts/build-lemonade.sh`; its `npm ci` needs the network); a readable kernel image for 1bit OS,
   `/boot/vmlinuz-$(uname -r)` or `VMLINUZ=<copy>` (Ubuntu's `/boot/vmlinuz-*` is root-only).

scripts/build-ds4.sh

@@ -19,8 +19,9 @@
 # Builds DwarfStar pinned in third_party/ds4 (upstream antirez/ds4) on its HIP backend
 # (Strix Halo, gfx1151; make strix-halo) into <prefix>/hip/ds4-server, with ds4 and
 # ds4-bench beside it. The engine builds DwarfStar on HIP only: no CUDA, Metal or CPU
-# builds. Needs HIP, hipBLAS, hipBLASLt, rocBLAS, rocWMMA and hipCUB: ROCM_PATH, else
-# TheRock's SDK under /opt/rocm-therock, else /opt/rocm. ROCM_ARCH overrides gfx1151.
+# builds. Needs HIP, hipBLAS, hipBLASLt, rocBLAS, rocWMMA and hipCUB: ROCM_PATH, else the pinned
+# toolchain under third_party/toolchain (scripts/fetch-rocm-sdk.sh, config/hrx-toolchain.config),
+# else TheRock's SDK under /opt/rocm-therock, else /opt/rocm. ROCM_ARCH overrides gfx1151.
 # DS4_TEST=1 also runs DwarfStar's model-free routed-MoE test on the GPU (make test-mxfp4-rocm).
 set -euo pipefail
 prefix=${1:?usage: build-ds4.sh <prefix>}
@@ -60,14 +61,32 @@ jobs=${CMAKE_BUILD_PARALLEL_LEVEL:-$(nproc)}   # the weekly job and thermal guar
 
 rocm=${ROCM_PATH:-}
 if [ -z "$rocm" ]; then
-    for d in /opt/rocm-therock/lib/python3*/site-packages/_rocm_sdk_devel /opt/rocm; do
-        [ -x "$d/bin/hipcc" ] && { rocm=$d; break; }
+    # The pinned tree copy, resolved from the pin file (version and target) rather than from a glob: a
+    # glob takes whatever sorts first, so after a version bump the old SDK would win silently (pi-prs's
+    # review of #771). Then the box's TheRock, then a distro ROCm.
+    pinned=
+    pinfile=$root/config/hrx-toolchain.config
+    if [ -r "$pinfile" ]; then
+        pinned=$root/third_party/toolchain/rocm-sdk-$(sed -n 's/^version=//p' "$pinfile" | tail -1)-$(sed -n 's/^gfx=//p' "$pinfile" | tail -1)
+    fi
+    for d in "$pinned" /opt/rocm-therock /opt/rocm; do
+        [ -n "$d" ] && [ -x "$d/bin/hipcc" ] && { rocm=$d; break; }
     done
 fi
-[ -n "$rocm" ] && [ -x "$rocm/bin/hipcc" ] || { echo "no ROCm with bin/hipcc: set ROCM_PATH"; exit 1; }
+[ -n "$rocm" ] && [ -x "$rocm/bin/hipcc" ] ||
+    { echo "no ROCm with bin/hipcc: set ROCM_PATH, or fetch the pinned toolchain (scripts/fetch-rocm-sdk.sh)"; exit 1; }
+# The gfx device library (the amdgcn bitcode) is inside the SDK's pip tree, not under <root>/lib, in
+# the 2026-10-31 layout: without --rocm-device-lib-path hipcc dies with "cannot find ROCm device
+# library", and the build then needs no HIP_DEVICE_LIB_PATH (engine#713).
+device_lib=
+for d in "$rocm" $rocm/lib/python3*/site-packages/_rocm_sdk_core; do
+    [ -d "$d/lib/llvm/amdgcn/bitcode" ] && { device_lib=$d/lib/llvm/amdgcn/bitcode; break; }
+done
+device_lib_flag=
+[ -n "$device_lib" ] && device_lib_flag=" --rocm-device-lib-path=$device_lib"
 # -isystem: clang otherwise appends the ROCm include directory after /usr/include,
 # so a distro HIP there (another version) shadows this one and the build fails
-cflags="-O3 -ffast-math -g -fno-finite-math-only -pthread -D__HIP_PLATFORM_AMD__ -Wno-unused-command-line-argument --offload-arch=${ROCM_ARCH:-gfx1151} -isystem $rocm/include"
+cflags="-O3 -ffast-math -g -fno-finite-math-only -pthread -D__HIP_PLATFORM_AMD__ -Wno-unused-command-line-argument --offload-arch=${ROCM_ARCH:-gfx1151} -isystem $rocm/include$device_lib_flag"
 libs="-L$rocm/lib -Wl,-rpath,$rocm/lib -lm -pthread -lhipblas -lhipblaslt -lrocblas"
 (cd "$work" && ROCM_PATH=$rocm HIP_PATH=$rocm make -j"$jobs" strix-halo \
     HIPCC="$rocm/bin/hipcc" ROCM_CFLAGS="$cflags" ROCM_LDLIBS="$libs")