fix(rocm-compilersupport): teach rocm-llvm clang to find the AZL GCC toolchain

AZL's azurelinux-rpm-config overlay changes %_vendor from "redhat" to
"azurelinux", so GCC installs its runtime objects (crtbeginS.o, libgcc,
libstdc++, etc.) under /usr/lib/gcc/<cpu>-azurelinux-linux/<ver>/. The
upstream clang GCCInstallationDetector triple list in
clang/lib/Driver/ToolChains/Gnu.cpp only knows about a fixed set of
vendor strings ("redhat", "suse", "amazon", ...) and has no "azurelinux"
entry, so any clang built without an AZL-aware config silently fails to
find the GCC install and produces link errors like:

    ld.lld: error: cannot open crtbeginS.o: No such file or directory
    ld.lld: error: unable to find library -lstdc++
    ld.lld: error: unable to find library -lgcc_s / -lgcc

The system llvm / llvm20 packages already work around this by writing
%{_target_platform}-clang.cfg files into /etc/clang containing
"--gcc-triple=%{_target_cpu}-%{_vendor}-linux". The rocm-llvm clang
shipped here lives at /usr/lib64/rocm/llvm/bin/ and does not read
/etc/clang, so it needs its own per-binary config file.

This was breaking the mivisionx build on x86_64 (and would similarly
break every other ROCm consumer that drives the rocm-llvm clang
directly, e.g. hipblaslt, hipcub, hipfft, rocfft, rocblas, miopen).
A rebuild of rocm-compilersupport itself also fails for the same reason
because the multi-stage %build uses its own freshly-built clang to
compile each subsequent stage.

Add three spec-search-replace overlays that drop clang.cfg / clang++.cfg
with --gcc-triple=%{_target_cpu}-%{_vendor}-linux in three places:

  1. Next to the stage-1 clang inside build-llvm/bin so stage 2+ of the
     in-package %build can compile and link.
  2. Pre-staged inside build-llvm-2/bin before stage-2 %cmake_build runs
     so the LLVM "runtimes" sub-build (compiler-rt, libcxx, libcxxabi)
     can configure once stage-2 clang is produced.
  3. Installed into %{bundle_prefix}/bin alongside the shipped clang so
     every downstream ROCm consumer sees the right toolchain triple.

Clang automatically reads "<argv0>.cfg" from its own directory before
any system config dir, so dropping the file is sufficient — no source
patch and no version-specific maintenance. The cfg payload uses
%_vendor / %_target_cpu so it transparently follows future arch and
vendor changes. The existing "%{bundle_prefix}/bin/clang*" glob in
%files -n rocm-clang already picks up the new files.

This mirrors the existing approach in base/comps/llvm and
base/comps/llvm20 rather than introducing a new mechanism.

Author: christopherco

base/comps/rocm-compilersupport/rocm-compilersupport.comp.toml

@@ -24,10 +24,76 @@ release = { calculation = "manual" }
 #   1. feat: introduce deterministic commit resolution via Azure Linux lock file
 #   2. fix(rocm-compilersupport): set manual release calculation
 #   3. fix(rocm-compilersupport): introduce azl_release counter
-azl_release = "3"
+#   4. fix(rocm-compilersupport): teach rocm-llvm clang to find the AZL GCC toolchain
+azl_release = "4"
 
 [[components.rocm-compilersupport.overlays]]
 description = "Switch hard-coded Release prefix to %{azl_release}-driven formula so AZL-only rebuilds bump cleanly without manual edits"
 type = "spec-search-replace"
 regex = '''Release:        15\.rocm%\{rocm_version\}%\{\?dist\}'''
 replacement = '''Release:        %[15 + %{azl_release}].rocm%{rocm_version}%{?dist}'''
+
+[[components.rocm-compilersupport.overlays]]
+# After the stage-1 LLVM is built, the spec uses its freshly-built clang to
+# compile every subsequent stage (stage-2 llvm, device-libs, comgr, hipcc).
+# That stage-1 clang has the same GCC-toolchain-detection problem as the
+# installed copy: upstream clang doesn't know the "azurelinux" vendor and so
+# fails to locate /usr/lib/gcc/<cpu>-azurelinux-linux/<ver>/crtbeginS.o etc.
+# Drop a clang.cfg/clang++.cfg next to the stage-1 binaries so every later
+# stage in this %build can find the toolchain.
+description = "Drop clang.cfg / clang++.cfg next to the in-tree stage-1 clang so later build stages can locate the Azure Linux GCC toolchain"
+type = "spec-search-replace"
+regex = '''build_stage1=\$p/build-llvm'''
+replacement = '''build_stage1=$p/build-llvm
+
+# AZL: same --gcc-triple fix as for the installed binaries, but applied to
+# the stage-1 clang inside the build tree so stage 2+ can compile/link.
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > $build_stage1/bin/clang.cfg
+cp -p $build_stage1/bin/clang.cfg $build_stage1/bin/clang++.cfg'''
+
+[[components.rocm-compilersupport.overlays]]
+# Stage 2 builds the LLVM "runtimes" project (compiler-rt, libcxx, libcxxabi)
+# as a sub-build that re-invokes CMake using the freshly-built stage-2 clang
+# at build-llvm-2/bin/. That sub-build re-runs the compiler/linker probes
+# and hits the same GCC-toolchain-detection failure as stage 1 unless its
+# clang has a config file alongside it. Drop the cfg files into the stage-2
+# bin directory before %cmake_build runs; they sit there until clang is
+# built and are picked up automatically on first invocation.
+description = "Drop clang.cfg / clang++.cfg into the stage-2 build tree so the LLVM runtimes sub-build can find the Azure Linux GCC toolchain"
+type = "spec-search-replace"
+regex = '''-DLLVM_ENABLE_RUNTIMES=%\{llvm_runtimes\}'''
+replacement = '''-DLLVM_ENABLE_RUNTIMES=%{llvm_runtimes}
+
+# AZL: pre-stage the clang config file inside build-llvm-2/bin so the
+# LLVM runtimes sub-build (which invokes the just-built stage-2 clang to
+# configure compiler-rt/libcxx/libcxxabi) can locate the Azure Linux GCC
+# toolchain. The .cfg only needs to exist by the time clang is invoked.
+mkdir -p $PWD/build-llvm-2/bin
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > $PWD/build-llvm-2/bin/clang.cfg
+cp -p $PWD/build-llvm-2/bin/clang.cfg $PWD/build-llvm-2/bin/clang++.cfg'''
+
+[[components.rocm-compilersupport.overlays]]
+# AZL changes %_vendor from "redhat" to "azurelinux" (see azurelinux-rpm-config),
+# so GCC installs its runtime objects under /usr/lib/gcc/<cpu>-azurelinux-linux/<ver>/.
+# Upstream clang's GCCInstallationDetector triple list does not include the
+# "azurelinux" vendor, so without help rocm-llvm's clang can't find crtbeginS.o /
+# libstdc++ / libgcc and link of any C++ test program (e.g. CMake compiler probe)
+# fails with "cannot open crtbeginS.o" and "unable to find library -lstdc++".
+#
+# The system llvm/llvm20 packages work around this by writing a per-triple
+# clang config file under /etc/clang. The rocm-llvm clang at
+# %{bundle_prefix}/bin/ does not read /etc/clang, so we drop clang.cfg and
+# clang++.cfg next to the binaries (clang reads "<argv0>.cfg" from its own
+# directory before any system dir). The cfg file forces --gcc-triple to the
+# AZL triple so the GCC toolchain is detected.
+description = "Drop clang.cfg / clang++.cfg next to rocm-llvm's clang so it can find the Azure Linux GCC toolchain (vendor=azurelinux, not redhat)"
+type = "spec-search-replace"
+regex = '''# Remove lld's libs'''
+replacement = '''# AZL: drop clang config files so rocm-llvm's clang can locate the Azure Linux
+# GCC toolchain at /usr/lib/gcc/%{_target_cpu}-%{_vendor}-linux/ (upstream clang
+# only knows the "redhat", "suse", "amazon", etc. vendor strings).
+mkdir -p %{buildroot}%{bundle_prefix}/bin
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > %{buildroot}%{bundle_prefix}/bin/clang.cfg
+cp -p %{buildroot}%{bundle_prefix}/bin/clang.cfg %{buildroot}%{bundle_prefix}/bin/clang++.cfg
+
+# Remove lld's libs'''

locks/rocm-compilersupport.lock

@@ -2,5 +2,5 @@
 version = 1
 import-commit = '878261eeebbede5f9f220522155fb1ccd8110df8'
 upstream-commit = '878261eeebbede5f9f220522155fb1ccd8110df8'
-input-fingerprint = 'sha256:ba5c7c12d93828b38f2bfed2431fba93ff016e2b23620b706ca356cc6b2a3115'
+input-fingerprint = 'sha256:17106d9425e94416d13ba712c4186e855ff7ea5c6ac1cc14aea2bdfb7fbbb521'
 resolution-input-hash = 'sha256:466421704711c4fd3c71f0b2ed715a0e61d49e3e26f3a2637fee755795849c8e'

specs/r/rocm-compilersupport/rocm-compilersupport.azl.macros

@@ -1,3 +1,3 @@
 # Macros file automatically generated by azldev.
 # Do not edit manually; changes will be overwritten.
-%azl_release 3
+%azl_release 4

specs/r/rocm-compilersupport/rocm-compilersupport.spec

@@ -463,6 +463,11 @@ popd
 
 build_stage1=$p/build-llvm
 
+# AZL: same --gcc-triple fix as for the installed binaries, but applied to
+# the stage-1 clang inside the build tree so stage 2+ can compile/link.
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > $build_stage1/bin/clang.cfg
+cp -p $build_stage1/bin/clang.cfg $build_stage1/bin/clang++.cfg
+
 %global llvmrocm_stage1_config \\\
     -DCMAKE_AR=$build_stage1/bin/llvm-ar \\\
     -DCMAKE_C_COMPILER=$build_stage1/bin/clang \\\
@@ -501,6 +506,14 @@ export LD_LIBRARY_PATH=$PWD/build-llvm-2/lib
        -DLLVM_TOOL_LIBCXX_BUILD=ON \
        -DLLVM_ENABLE_PROJECTS=%{llvm_projects} \
        -DLLVM_ENABLE_RUNTIMES=%{llvm_runtimes}
+
+# AZL: pre-stage the clang config file inside build-llvm-2/bin so the
+# LLVM runtimes sub-build (which invokes the just-built stage-2 clang to
+# configure compiler-rt/libcxx/libcxxabi) can locate the Azure Linux GCC
+# toolchain. The .cfg only needs to exist by the time clang is invoked.
+mkdir -p $PWD/build-llvm-2/bin
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > $PWD/build-llvm-2/bin/clang.cfg
+cp -p $PWD/build-llvm-2/bin/clang.cfg $PWD/build-llvm-2/bin/clang++.cfg
 
 %cmake_build -j ${JOBS}
 popd
@@ -706,6 +719,13 @@ find %{buildroot}%{bundle_prefix}/lib -type f -name '*.so*' -exec strip {} \;
 find %{buildroot}%{_libdir}           -type f -name '*.so*' -exec strip {} \;
 %endif
 
+# AZL: drop clang config files so rocm-llvm's clang can locate the Azure Linux
+# GCC toolchain at /usr/lib/gcc/%{_target_cpu}-%{_vendor}-linux/ (upstream clang
+# only knows the "redhat", "suse", "amazon", etc. vendor strings).
+mkdir -p %{buildroot}%{bundle_prefix}/bin
+echo "--gcc-triple=%{_target_cpu}-%{_vendor}-linux" > %{buildroot}%{bundle_prefix}/bin/clang.cfg
+cp -p %{buildroot}%{bundle_prefix}/bin/clang.cfg %{buildroot}%{bundle_prefix}/bin/clang++.cfg
+
 # Remove lld's libs
 rm -rf %{buildroot}%{bundle_prefix}/include/lld
 rm -rf %{buildroot}%{bundle_prefix}/lib/cmake/lld