[CongMa13]

feat(rocke): ask the compiler which intrinsics each GPU can actually run, and commit the answer

Branch: users/congma/ck/rocke-arch-domain-table
Base: develop

ISSUE ID : AICK-2272

---

Summary — For human reviewers

The short version

rocke has two gates on what it emits. Byte-identity proves the two engines emit the
same bytes; the golden proves those bytes do not change. Neither asks the AMDGPU
toolchain whether the IR is legal, so an illegal construct emitted stably and by
both engines is green in both.

And when rocke emits a declare for an llvm.amdgcn.* intrinsic, it decides what
to declare based on the LLVM version it is building against. It never asks the other
half of the question: can the GPU we are compiling for actually run this? That
question is asked nowhere at build time — the target architecture picks an ISA
backend and never reaches the declaration table at all.

This PR closes both gaps, in that order.

First it adds a gate that pushes every kernel in the representative corpus through
clang to a linked binary, which is the only oracle that catches an intrinsic
that does not exist. That gate immediately found three dead declarations in the
table, two of them with signatures LLVM would have rejected, and they are deleted.

Then it answers the architecture question by measurement: probe the toolchain once
for every (intrinsic, target) pair in the table, and commit the result as a data
file — one per LLVM vintage, three of them, every cell machine-measured. Nothing
reads those files yet. That is deliberate: a table nobody consumes cannot break
anything, and it surfaces the defects that justify the rest of the work.

Why a link, and not a verify

This is the part that looks like it should work and does not. A declare for an
intrinsic that does not exist passes opt -passes=verify, and passes clang -S
too. The backend assumes the unknown llvm.* name is an ordinary function defined
somewhere else and emits a GOT-relative call to it. Nothing objects until the
linker cannot find the symbol.

flowchart LR
    A[emit IR] --> B[opt -passes=verify]
    B -->|accepts| C[clang -S]
    C -->|accepts| D[link]
    D -->|undefined symbol| E((caught only here))
    style E fill:#fdd

Loading

A check that stops at compile is blind to the entire fictional-intrinsic bug class,
and the declaration table had several. The same fact is why the architecture probes
later in this PR also run through to a link rather than to an object.

Why the architecture table has to be measured rather than written down

The table is roughly 167 intrinsics across 7 wired targets — about 1,200 cells per
vintage. Nobody can fill that in by hand and be right. An earlier attempt did fill
in a small part of it by hand, and when those rows were re-checked on a second LLVM
version, two of five did not survive. That is the argument for generating it, in
miniature.

Generating it once is also not enough. A generated file that nothing checks drifts
away from its generator, and a stale availability table is worse than no table at
all, because people trust it. So the gate ships with the generator, not after it.
The gate has already earned its place several times over: every defect in the list
below was found because something re-ran the generator and compared.

The parts that are easy to get wrong

Most of the work here is not the probing. It is making the probe tell the truth. The
same error keeps reappearing in different disguises, and it is always the same shape
— the probe failed for a reason that has nothing to do with the target, and the
failure got recorded as a fact about the target.

flowchart TD
    P[probe fails] --> W{whose fault?}
    W -->|target cannot lower it| A[arch_absent — a real answer]
    W -->|our module was malformed| E[probe_error — fix the generator]
    W -->|compiler crashed or hung| N[no data — stay silent]
    W -->|clang cannot target this| U[no data — stay silent]
    A --> D[the only status allowed<br/>to mean 'no']
    style D fill:#dfd
    style E fill:#fdd

Loading

Seven things had to be right:

The oracle has to be a link — for the reason above.

The LLVM-version question has to be asked first. Not for speed — it is the only
stage that can answer a key whose code generation crashes. An unrecognised llvm.*
name taking a metadata operand gets lowered as an ordinary call, and taking the
alignment of a metadata argument segfaults the backend. Asking "does this name
exist" with a text round-trip avoids the crash entirely.

Probes must be compiled at -O0. At -O3 the optimiser can delete the very
call being asked about. A module with nothing left links happily, and the probe
records "available" for an intrinsic the target does not have. This is not
hypothetical: one cross-lane intrinsic is the identity when its input is uniform, so
the optimiser folded it away, the object contained no such instruction, and the link
succeeded. Nine keys are foldable this way.

A hang is not an answer either. One buffer intrinsic never terminates under the
oldest vintage at -O0, on any targetable arch. With no timeout the sweep simply
waited — and the column recorded ok for all six cells, because it had been blessed
before -O0 became mandatory and at -O3 the call was being deleted. Six cells
claimed an intrinsic was available on hardware where the compiler cannot even finish
compiling it. Timeouts now have their own status, and columns now record how the
question was asked, so a column measured the wrong way can be told from one measured
right. That provenance is the check that would have caught it.

A non-answer must never be recorded as a "no". Seven statuses, not two. "This
target cannot lower it" is a real negative. "This clang cannot target this
architecture", "asking killed the compiler", "asking hung the compiler", and "our
probe module was malformed" are absence of data, and collapsing them into the
negative is the main way this becomes worse than having no table.

An operand we chose badly is our fault, not the target's. The probe passed the
literal 0 for every constant-required operand. Where 0 is not a legal value, the
backend reports "Cannot select" — which is exactly what a genuinely unsupported
target reports. One load-to-LDS intrinsic takes a transfer size in bytes, and 0 is
not one, so every column said "no target can lower this" about an intrinsic that has
a builder entry point, a lowering handler in both engines, and a production instance
whose own comments record the resulting instructions. Three of those seven cells
were wrong, on a live path. There is no diagnostic that says "your operand value was
out of range", so the only way to tell the two apart is to ask again with a
different value — and the winning value is now recorded in the cell, because
otherwise a first-try answer and a fourth-try answer look identical.

Transient failures must not be committed as facts. Regenerating one column gave
a different answer roughly one run in three: under parallel execution the probes
fork enough linkers to occasionally hit the host's process limit, and that abort was
being recorded as a permanent compiler crash. The root cause was sizing the worker
pool from the host's CPU count — which on a scheduler-pinned node reported 384
against an affinity of 2. A real result is stable under retry and a resource failure
is not, so a serial second pass separates them without anyone having to guess; and
the pool is now sized from this process's actual share. The same fix is lifted into
a shared helper, because the byte-identity gate was asking ninja for 384 compile
jobs on the same two cores.

The newest vintage taught us words we did not know

The third column was the one with no machine-checked data behind it, for no better
reason than nobody having a vehicle to run it in. Its first run came back with 27
cells of "the generator is broken" — and both causes were the same thing from
different angles: that LLVM words two diagnostics differently, and the classifier
had only been taught the older wordings.

One is a target saying outright that an intrinsic is not supported on this
subtarget, where the older vintages only imply it by failing to select. Twelve cells
had a clear answer and it was being thrown away.

The other is the operand defect above, caught one stage earlier — in the verifier,
before codegen — and it is the only one of the three that says what would have been
acceptable. The candidate list the sweep tries now matches the domain that
diagnostic enumerates, rather than the one we had inferred.

The result worth having: after all three columns were regenerated with what the
newest vintage taught us, the two older columns changed in nothing but the
generator stamp. The fix was in what we could read, not in what we measure.

What this found

Three dead declarations, deleted. None had a call site in either engine, so
nothing could ever emit them — table weight that outlived its caller. Two were also
simply wrong: declared with a return type and argument count LLVM does not accept.
No kernel had hit the mismatch because no lowering handler existed. Deleting them
means whoever wires the op up writes a correct declaration rather than inheriting a
broken one.

One that looked dead and is not, deliberately kept. The working notes said a
packed-f16 atomic declaration was dead too. It is not — both engines need it. LLVM
auto-upgrades the declaration away, which is why it still compiles. Making rocke
emit the modern form directly is an emission change needing a golden re-bless, so it
is recorded as a follow-up rather than folded in.

Two corpus cases that do not compile at all, found by the new link gate, on an
attention path at one target. They land in an allowlist with the defect named.

And from the measurement alone, with nothing consuming the table yet:
intrinsics whose names exist in no shipped LLVM; intrinsics whose names exist but
which no wired target can lower; one case where the compiler segfaults rather than
reporting that a target cannot select an instruction; and one where it hangs
indefinitely. Fixes for these are separate changes — this PR is the measurement,
deliberately kept apart from acting on it.

Honesty about coverage

Two different limits, and they are not the same.

The link gate can only validate the host's own LLVM vintage. Modules lower at
any vintage, but there is no local compiler for the others; those report
UNVALIDATED, never green. With no LLVM tools at all the gate self-skips loudly.

The architecture table can only be measured on the LLVM the machine has. All
three vintages now have a complete, machine-measured column, which was not true when
this branch started — one column lagged the declaration table and reported itself as
incomplete rather than pretending. That machinery stays, because it will be true
again the next time an intrinsic is wired: a key that is in the artifact but gone
from the table is a hard failure anywhere, because anyone can fix it; a key that has
never been measured fails only on a host running that LLVM, and is a named skip
elsewhere that says which toolchain is needed.

No column is ever reported as green on a machine that could not measure it.

One thing the drift gate deliberately forgives: the exact compiler build. Two
independent builds of the same vintage reproducing a column cell for cell is not
staleness — it is better evidence than a byte match, because it shows the column
describes the vintage rather than one machine. Nothing else is forgiven, including
the rest of the toolchain record, because those fields say how the question was
asked rather than who answered it, and that is exactly where a wrong measurement
hides.

How this was tested

Regeneration is byte-identical run to run, and all three columns were regenerated
against compiler builds different from the ones that blessed them. The drift gate
was verified in both directions: green on a clean tree; red on a fabricated cell, a
dropped key, a changed probe method with identical cells, and an unparseable column.
Its structural half runs in a fraction of a second with no toolchain present, which
is why this is a test rather than a nightly job.

For the declaration deletions: the golden IR anchors and the declaration-table
parity check both green, and the link gate green with no new failures. Note that the
commit message for that change records "the byte-identity gate could not run on this
host -- no cmake"; the gate does run, in containers, and has since been green across
this branch and the one stacked on it. The claim in that message is stale, not the
result.

No emitted bytes change. The only emitter-adjacent edit is the removal of three
declarations that nothing could reach.

Reviewing this

16 commits. The first two are the link gate and the dead-declaration deletion it
justified. The next two build the probe generator and the multi-column schema. The
remaining twelve are each a defect in the measurement found by re-running it, which
is the intended reading order — the commit messages are where the evidence for each
lives.

14 files. Three are the data columns and account for ~17,000 of the ~20,100 added
lines; the two engine-side files are deletions only.

---

Summary — For AI reviewers

Change surface

tools/gen_arch_domain.py                             +1005   the arch probe generator
tools/check_ir_validity.py                            +379   the emitted-IR link gate
tools/_hostcaps.py                                      +65   shared CPU-share helper
tools/check_byte_identity.py                           8 +-   second caller of the above
tests/core/test_arch_domain_artifact.py               +487   the drift gate
tests/run_all.py                                       +16   wires both gates in
TESTING.md                                             +40   documents both gates
.../arch/data/intrinsic_arch_domain.llvm20.json      +5841   committed column
.../arch/data/intrinsic_arch_domain.llvm22.json      +5703   committed column
.../arch/data/intrinsic_arch_domain.llvm23.json      +5650   committed column
python/rocke/core/lower_llvm.py                        -19   three declares removed
cpp/core/lower_llvm/data.cpp                            -7   the same three, C++ side
dsl_docs/development/arch_axis_proposal.md             +464   design record
dsl_docs/development/multi_toolchain_strategy.md       +438   design record

The two engine files change by deletion only, symmetrically, and every deleted
key has zero _need() call sites in either engine — so no reachable path changes
and no emitted byte can move. Nothing reads the arch-domain artifact. Byte-identity
and the golden are untouched by construction; confirm the symmetry, because a
one-sided deletion is exactly what byte-identity exists to catch.

The gaps being closed

check	proves	blind to
byte-identity	the two engines emit the same bytes	whether those bytes are legal
golden IR anchors	the bytes do not change	whether they were ever right
check_ir_validity.py (new)	every corpus module compiles and links	only the host's vintage; others report UNVALIDATED
the arch-domain artifact (new)	which (intrinsic, target) pairs lower, per vintage	nothing consumes it yet — that is the next change

Availability factors as:

available(key, arch, flavor) ≈ arch_domain(key, arch) ∧ exists(key, flavor)

rocke resolves declarations on the flavor axis only. The arch axis is asked
nowhere. This PR measures the missing factor.

Note the factorization is not clean, and the code depends on that: arch_domain is
undefined wherever the name is absent, so the product only holds because the
flavor axis is evaluated first and short-circuits. A schema storing one arch set per
key with no flavor dimension would have to invent those cells. Check that no code
path evaluates the arch axis for a key the flavor axis already rejected.

Properties to verify

Each is falsifiable against the code.

1. Both oracles are a link, not a verify and not a codegen. A declare for a
   nonexistent intrinsic passes both opt -passes=verify and clang -S; the
   backend lowers it to a GOT-relative external call. Confirm neither the corpus
   gate nor the arch probe treats codegen success as an answer.

2. Every compile runs in a subprocess. A backend failure is a
   report_fatal_error, which terminates the process rather than raising — compiling
   in-process means one bad module kills the run and emits no report. The isolation
   is a correctness requirement, not a performance choice. Confirm a killed child is
   classified as a crash rather than retried into success.

3. Tool resolution prefers the ROCm install over PATH. A ROCm ships clang and
   opt under its own tree without putting them on PATH, and the tool that is on
   PATH may be a different vintage than the comgr the modules were lowered against.
   Confirm PATH is checked last.

4. Two stages, flavor first, and the ordering is load-bearing. Stage one is an
   opt -S round-trip: LLVM resolves a recognised llvm.* declare on parse
   (attaching attribute groups, remangling overloads, or letting AutoUpgrade consume
   it entirely), while an unrecognised name round-trips verbatim. It must run first
   because it is the only stage that can answer a key whose codegen crashes — an
   unknown llvm.* with a metadata operand is lowered through
   TargetLowering::LowerCallTo, and taking a metadata argument's alignment faults.
   Confirm no path reaches stage two for a name_absent key.

5. -O0 is mandatory for the probes. At -O3 the IR pipeline can delete the
   probed call, leaving a module that links with nothing selected — a false ok.
   Nine keys are foldable this way. Confirm the optimisation level cannot be raised
   by configuration or inherited from the environment, and that it is recorded in the
   artifact rather than only applied.

6. Every probe has a timeout, and a timeout is not a negative. One key does not
   terminate at -O0 on any targetable arch. toolchain_timeout must join
   target_unsupported, toolchain_crash and probe_error as no-data. Confirm the
   serial retry re-runs a timeout on the same budget — the retry exists to remove
   contention, not to grant more time — and that no path lets an eventually-finishing
   probe upgrade a timeout into ok.

7. Seven statuses, and only one of them is a negative. ok, arch_absent,
   name_absent, target_unsupported, toolchain_crash, toolchain_timeout,
   probe_error. Only arch_absent means "this target cannot lower it". Verify no
   aggregation, serialization, or summary path collapses a no-data status into a
   negative. The asymmetry is the reason: a false arch_absent breaks a working
   build loudly and safely; a false ok silently admits a kernel that cannot run.

8. probe_error must be absent from every committed column, not merely valid.
   It means our own probe module was malformed — a generator defect, not a
   measurement. Confirm the gate asserts absence rather than membership in the status
   enum. All three committed columns currently hold zero.

9. Probe operands are real SSA values, never poison. poison is a valid
   constant of every first-class type and therefore looks like the generic choice,
   but it makes the probe lie: a poison i32 sends one buffer intrinsic into a
   legalisation failure on a target where concrete integers lower cleanly — a false
   arch_absent.

10. The literal-operand rescue is scoped, and its verdict is final. Some operands
    must be immediates even where the declaration carries no immarg; one vintage
    fails to legalise a variable operand while newer ones reject it in the verifier,
    so all those diagnostics trigger the retry, and several literal values are tried
    because a value out of range for one operand kind is in range for another. Two
    constraints to check: the rescue must be scoped to those diagnostics (literals
    could otherwise constant-fold an unsupported intrinsic away and manufacture an
    ok), and once every integer operand is a constant a surviving legalisation
    failure is the target's answer, recorded as arch_absent rather than falling back
    to the original failure. The verifier's immarg complaint is deliberately
    excluded from that final-answer rule — surviving the sweep there means the
    non-immediate operand is not an integer, which is our module's fault.

11. The immediate-value sweep fires on arch_absent and on probe_error, and
    records its winner. An illegal value in a constant-required operand produces
    the same "Cannot select" as an unsupported target, and no diagnostic
    distinguishes them, so the only discriminator is asking again with a different
    value. Confirm: the sweep is built by comparing module text against the base
    probe, so a declare with no integer constant operand produces no variants and
    costs nothing; the winning value lands in the cell so a first-try ok and a
    later-candidate ok are distinguishable; and a cell that started as
    probe_error takes the first real classification the sweep produced rather
    than keeping its original evidence — committing probe_error there would report
    the generator broken for a target that simply cannot lower the call.

12. Serial retry separates resource failures from real ones. A real result is
    stable under retry; a host process-limit abort is not. Confirm the retry covers
    the crash, timeout and probe_error statuses, and that a crash reproducing
    serially is still recorded as a crash.

13. Worker count comes from this process's share, not the host's.
    os.cpu_count() reports the machine; on a scheduler-pinned node that read 384
    against an affinity of 2, which is what produced the process-limit aborts in the
    first place. _hostcaps takes the narrowest of affinity, a cgroup v2 then v1 CFS
    quota, and the host count. Confirm a fractional quota share rounds up to one
    whole worker — rounding down is a hang, not a slow build — that the quota path
    takes its root as a parameter so it is testable on a host imposing none, and that
    the extra min(8, ...) cap stays at the probe call site, since it is about
    clang's own process fan-out and does not apply to the build caller.

14. Toolchain identity is recorded, cross-checked, and partially forgiven. The
    artifact records the clang identity, the resolved flavor, the generator version,
    the probe cflags and the probe timeout; the generator refuses to run when the
    recorded flavor and the compiler disagree. The drift check compares parsed
    documents and forgives a difference in the clang build alone — two builds of one
    vintage agreeing cell for cell is evidence, not staleness. Confirm nothing else
    in the toolchain record is forgiven: those fields say how the question was asked,
    and a generator or cflags or timeout change means the committed answers came from
    a method no longer in use, which demands a re-bless even when every cell agrees.

15. Crash evidence is host-independent. (core dumped) is a property of the
    host's core-dump settings, not of the fault, so it is normalised away before
    being committed. Without this the drift gate reports drift between two machines
    observing the identical crash. Relatedly, probes run from the scratch directory,
    because probing is expected to crash clang and a core file must not land in the
    worktree.

16. The gates split by who can act on the failure. For the artifact: a stale key
    — in the artifact, gone from the declaration table — needs no toolchain to fix
    and is a hard failure on every column from any host; a key that has never been
    measured fails only for the host's own vintage and is a named skip elsewhere,
    naming both the keys and the toolchain required. For the link gate: only the
    host's vintage can go green, the rest report UNVALIDATED. Verify no aggregate
    exit path turns a skip or an UNVALIDATED column into a pass, and equally that one
    newly wired intrinsic cannot red the build on every machine until all toolchains
    have been run.

17. KNOWN_BAD only shrinks. Same convention and same rule as KNOWN_VIOLATIONS
    in test_library_layering.py. An entry that starts compiling is itself reported
    as a failure, so a fix cannot leave dead weight behind. It lands with two
    entries.

18. The three deleted declarations are unreachable, and the fourth was kept for a
    reason. Confirm each deleted key has zero _need() call sites in both engines,
    and that the packed-f16 atomic was not deleted — both engines need it, and LLVM
    auto-upgrading the declaration away is why it still compiles. Its replacement is
    an emission change requiring a golden re-bless, correctly deferred. The
    now-handler-less op names stay registered because they live in index-parallel
    arrays the serializer keys off; removing them is not a no-op.

19. Regeneration is byte-identical, which is what makes the check a usable gate
    rather than a source of noise. Confirm nothing non-deterministic reaches the
    serialized output — ordering, timestamps, paths, or parallelism-dependent
    iteration.

Repo rules that apply

• Byte-identity. The only engine-side edit is a symmetric deletion in both
  engines of keys with no call sites; confirm the symmetry and that no reachable
  path changed.
• No file under platform/ may hardcode an absolute path or escape the tree; anchor
  on __file__ or rocke.assets. tests/run_all.py enforces this and both new
  tools must satisfy it.
• Cross-platform Python only: tempfile, os.cpu_count(), pathlib,
  shutil.which. No /tmp, nproc, or sudo. The generator spawns parallel
  subprocesses and writes intermediate modules — check temp-dir handling and the
  worker-count derivation.
• torch is optional; numpy is the only hard dependency.
• Emitter code must never be run through ruff check --fix. lower_llvm.py is
  emitter code and its edit here is a hand-written deletion.
• Source change implies test change: _hostcaps carries the tests it was lifted
  with, now covering both callers; the artifact gate is new with the generator; the
  link gate is itself a test wired into run_all.py.

Known-weak points, stated so review can focus

• The leading-underscore module under tools/. _hostcaps.py is the only
  non-CLI module there; the naming is the only thing marking that distinction.
• One target is unprobeable on the oldest vintage by construction, recorded as
  target_unsupported rather than as a negative.
• The two design documents were untracked until this branch. An uncommitted
  document cannot be the record, which is most of why stale claims in them went
  unnoticed. They now keep the earlier hand-run probe table, but labelled as the
  argument that motivated the generator rather than as data. Check that labelling
  survived, and that no numeric claim in either document lacks a generated artifact
  behind it.
• A stale claim in one commit message. The deletion commit says byte-identity
  could not run on this host for want of cmake. It does run, in containers, and is
  green. The message is wrong; the result is not.
• The drift gate's regeneration half needs a toolchain; its structural half does
  not. Only the former can catch a wrong measurement rather than a missing one,
  so on hosts without LLVM the effective coverage is materially weaker than a green
  result suggests.
• The classifier is a list of diagnostic wordings. Three vintages have each
  contributed some; a fourth will contribute more, and the failure mode is
  probe_error cells rather than wrong answers — loud, but it means a new toolchain
  cannot be measured without a code change.

Scope calibration

A finding of the form "the emitter still does not consult this table" is out of
scope and expected — consumption is deliberately a later change, so that the table
can be validated against real kernels before it can block anyone. A finding that the
intrinsics shown to be missing or unlowerable are not fixed here is likewise out
of scope: this PR is the measurement, and acting on it is separate work. A finding
that the two allowlisted corpus cases still fail is out of scope — they are named,
owned, and the allowlist is the mechanism that keeps them visible.

What review cannot establish from the diff

Whether the measurements are correct depends on the toolchain that produced them.
A static review can confirm the oracles are links, the ordering short-circuits, the
optimisation level is pinned, the statuses do not collapse, and the gates fail in
both directions. It cannot confirm that any particular cell reflects what the GPU
can really run.

---

Test plan

• Three consecutive regenerations byte-identical, and identical to the committed
  columns
• All three columns regenerated against a compiler build different from the one
  that blessed them, agreeing cell for cell
• Drift gate green on a clean tree
• Drift gate red on: a fabricated cell, a dropped key, a changed probe method
  with identical cells, an unparseable column
• Drift gate not red on a differing compiler build alone
• python -m pytest tests/core/test_arch_domain_artifact.py -q
• Emitted-IR link gate green, with the two allowlisted cases and no new failures
• Golden IR anchors green and declaration-table parity green after the three
  deletions
• byte-identity green in containers (the deletion commit's message claiming
  otherwise is stale)
• pre-commit run --from-ref origin/develop --to-ref HEAD from the repo root —
  not yet run; per-commit hooks passed on each commit
• Link gate green at the other two vintages — cannot run on one host; they
  report UNVALIDATED by design, never green

[therock-pr-bot]

✅ All Checks Passed — Ready for Review

Check	Status	Details
📝 PR Description	✅ Pass	—
⛔ Forbidden Files	✅ Pass	—
🧪 Unit Test	✅ Pass	—
🔎 pre-commit	✅ Pass	—
🚫 Draft PR	🔜 To Be Enabled	—
🚩 Feature Flag	🔜 To Be Enabled	—
📊 Code Coverage	🔜 To Be Enabled	—
🤖 therock-pr-bot	✅ Pass	—

🎉 All checks passed! This PR is ready for review.

📖 Need help? See the Policy FAQ for details on every check and how to fix failures.

🙋 Wish to Override Policy?

[therock-pr-bot]

🎉 All checks passed! This PR is ready for review.

[Copilot]

🟡 Changes recommended

One or more issues must be addressed before approval.

Get a fresh assessment by requesting another Copilot review.

Pull request overview

Adds toolchain-probed intrinsic availability artifacts and gates for LLVM/GPU compatibility, while removing invalid declarations from both Python and C++ tables.

Changes:

• Adds arch-domain generation, validation, and committed LLVM columns.
• Adds emitted-IR compile/link validity checking.
• Documents the multi-toolchain and architecture-axis strategy.

File summaries

File	Description
dnn-providers/hip-kernel-provider/rocke/TESTING.md	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/tools/gen_arch_domain.py	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/tools/check_ir_validity.py	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/tests/run_all.py	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/tests/core/test_arch_domain_artifact.py	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/python/rocke/core/lower_llvm.py	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/dsl_docs/development/multi_toolchain_strategy.md	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/dsl_docs/development/arch_axis_proposal.md	Updated as part of this pull request.
dnn-providers/hip-kernel-provider/rocke/platform/cpp/core/lower_llvm/data.cpp	Updated as part of this pull request.

Review details

Suppressed comments (6)

dnn-providers/hip-kernel-provider/rocke/platform/dsl_docs/development/arch_axis_proposal.md:380

• This status table says KNOWN_BAD remains empty, but the new validity gate defines two committed KNOWN_BAD entries in platform/tools/check_ir_validity.py:81-90. The document therefore misstates the current state of the gating policy; either update this row to acknowledge the allowlist or change the gate and its acceptance criteria consistently.

| `KNOWN_BAD` | stays empty; arch-unavailable keys become build errors, not allowlist entries |

dnn-providers/hip-kernel-provider/rocke/platform/dsl_docs/development/arch_axis_proposal.md:305

• The stated sweep size is inconsistent with the committed data: the llvm22 artifact has 1,169 cells over seven wired arches, which is 167 keys, not 148. Please update this design record or remove the fixed count so it cannot drift again.

Cost, measured: 148 keys × 7 arches on `llvm22`, ~15 s wall across cores. Cheap
enough to run in CI, not just on demand — which is why the gate is a test rather
than a nightly.

dnn-providers/hip-kernel-provider/rocke/platform/tests/run_all.py:192

• run_all.py --only is documented as a byte-identity family filter, but this forwards the same substring to check_ir_validity.py, which matches case IDs instead. A valid filter such as --only mfma can match the identity gate while matching no corpus cases, causing the new gate's FATAL: selection matched no cases exit and making the documented partial runner fail unexpectedly. Use a separate filter contract or do not forward this option to the IR gate.

        if args.only:
            ir_gate += ["--only", args.only]

dnn-providers/hip-kernel-provider/rocke/platform/tools/check_ir_validity.py:278

• The tool lookup deliberately falls back to PATH, but this gate never checks the selected clang's identity against the native flavor used by current_flavor()/comgr. With ROCKE_LLVM_BIN or PATH pointing at another LLVM, the gate can compile with a different intrinsic set and report a result for the wrong toolchain; the generator already rejects this mismatch, so apply the same provenance check here or fail closed.

    clang = _llvm_tool("clang")
    opt = None if args.no_verify else _llvm_tool("opt")

dnn-providers/hip-kernel-provider/rocke/platform/tools/gen_arch_domain.py:634

• If every literal retry returns the verifier's immarg operand has non-immediate parameter diagnostic, settled remains None and this falls back to the original arch_absent result. That records a probe/module defect as a target negative, contrary to the comment above and to the six-status contract; preserve the last retry result (typically probe_error) when no settled result exists.

            if settled is None and last and last[0] == STATUS_ARCH_ABSENT:
                settled = last
            status, evidence = settled or (status, evidence)

dnn-providers/hip-kernel-provider/rocke/platform/tools/gen_arch_domain.py:411

• The generator documentation says there are 149 keys, but the committed llvm22 column has 1,169 (key, arch) cells across seven wired arches, i.e. 167 keys. This is exactly the kind of fixed-count drift the PR says the artifact should prevent; update the statement or describe the count dynamically.

    reported ok for a target where the instruction does not exist. Nine of the
    149 keys are foldable this way. -O0 keeps the call alive to ISel, which is

• Files reviewed: 9/11 changed files
• Comments generated: 5
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[tenpercent]

Review of head 8c3a6544a45ba7696aceae40d921eafc42c1d89f: REQUEST CHANGES — three confirmed findings.

1. [P1 / high] The new test breaks installed pytest collection.
   test_arch_domain_artifact.py:49–58 imports gen_arch_domain from an adjacent tools/ directory. CMake installs this test but does not install the generator. Reproducing the installed layout produces ModuleNotFoundError: No module named 'gen_arch_domain' during collection, interrupting the pytest suite. The _DATA path also assumes the source-only python/rocke layout. Install the required tools and resolve data through the installed package, or explicitly exclude this source-only test from installed execution.

2. [P2 / medium] The default validity gate fails on targets the host compiler cannot support.
   check_ir_validity.py:314–327 classifies every compile rejection as an emission failure. With ROCm 7.1's LLVM 20, --only gemm --arch gfx1250 reports two new failures for invalid target ID 'gfx1250' and exits 1. These cases are also selected by the newly enabled default run_all.py gate. Treat unsupported targets as explicitly unvalidated, as the arch-domain generator already does, while continuing to validate supported targets.

3. [P2 / medium] Missing opt silently bypasses the required name check.
   gen_arch_domain.py:706–708 substitutes (True, "") when opt is unavailable. With tool discovery adjusted to simulate that environment and the real LLVM 20 clang, av.load.b128.p0 is recorded as toolchain_crash, and the generator writes the artifact with exit status 0. With opt present, the same declaration correctly resolves to name_absent. Require a successful name-check stage before generating an authoritative artifact; otherwise report the run as unvalidated.

Validation: 9 structural/CPU tests passed, including 2,352 subtests, and 11 AMDGPU lowering tests passed. A focused LLVM 20 compile/link probe also passed. Reviewed the GitHub diff and isolated exact-head sources. Full regeneration, C++ byte-identity builds, and GPU numerical tests were not run.

Assisted-by: codex / gpt-6-astra / medium

[cgmillette]

PR #12269 — AICK-2272 · head b2966e72

Verdict: ⚠️ REQUEST CHANGES — engine change is deletion-only (no codegen risk), but the drift gate can't execute in provider CI (N1).

#	Location	Finding	Sev
N1	CMakeLists.txt + test_arch_domain_artifact.py	test staged in rocke_pytest but import gen_arch_domain (tools/ not installed) + checkout-relative _DATA → errors/0 columns in provider artifact	MED
N2	check_ir_validity._compile	omits -nogpulib the probe generator deems required (foreign-ROCm device bitcode)	LOW

Legend — Sev: MED/LOW. Net-new only (existing reviewer comments excluded).

[tenpercent]

note: when you stack PRs it affects mergeability

[CongMa13]

Thanks all — every comment on this PR is addressed below, grouped by reviewer. Fixed 14, rebutted 1, left open with reasoning 1, plus 2 acknowledgements. All changes are in 69b8eba.

Verification for every claim below: the byte-identity gate and the emitted-IR validity gate were run at all three LLVM flavors (llvm20, llvm22, llvm23), and all three arch-domain columns were regenerated from scratch.

---

@cgmillette

N1 — the artifact test breaks an installed tree. Fixed both ways you suggested. _DATA now resolves through importlib.resources.files("rocke.core.arch") so it reads the installed package rather than the source tree, and the test itself is excluded from the installed tree, beside the existing test_wavescope_sidecar.py exclusion which is there for exactly this reason. It stays a source-tree gate because it imports the generator, deliberately — that is what keeps it in step with the generator about what "the decl table for a flavor" means. Verified against a mock install: 893 tests collect cleanly; restoring the file reproduces the aborting ModuleNotFoundError.

N2 — -nogpulib. Fixed. Verified it was a no-op first: identical verdicts across all 154 corpus cases with and without it, so this buys independence from the device-library install without moving any result.

---

@tenpercent

P1 — packaging / installed-tree failure. Same fix as N1 above.

On the JSON data files specifically: the existing rules already cover them, and that is now verified rather than assumed. pyproject.toml ships rocke = ["**/*.json"] for the wheel, and the install(DIRECTORY python/rocke ...) rule excludes only __pycache__/*.pyc, so both paths pick the new columns up. Confirmed by staging a mock install replicating the CMake exclusions and checking the JSON is present in the installed package. The real problem you hit was the test, not the data.

P2 — the default validity gate fails on targets the host compiler cannot support. Fixed. invalid target ID is now classified as unvalidated: excluded from the failure count, excluded from the pass count, and unable to mark a KNOWN_BAD entry stale. Supported targets continue to be validated normally. --strict still reds these, for the CI case where "we could not ask" should block.

Two notes. First, on the current tip your repro is not reachable as written — an llvm23-gated instance raises FATAL before the compile stage ever runs; that is fixed in this same round, and only then does this finding become observable again. Second, the llvm20 gate is now GREEN with 8 unvalidated cases — 4 for an untargetable arch, 4 requiring a newer LLVM — which is the shape this finding asked for.

P2 — missing opt silently recorded as success. Fixed, taking the "or fail" branch. The (True, "") fallback is gone; a missing opt now exits 1 having written nothing. Failure rather than an unvalidated run because no complete LLVM install ships clang without opt — checked across all three flavors' toolchains — so the combination means the environment is pointed at a partial install, not at a host with less to offer.

Your repro is what made the severity clear: a name_absent key recorded as toolchain_crash, with the process exiting 0. That also surfaced an adjacent hazard, now closed: ROCKE_LLVM_BIN used to be a first guess that fell through on a miss, so a prefix holding only a clang would silently resolve opt from a different install — and the flavor axis and the arch axis could then be measured by two different LLVM vintages and committed as one toolchain. It is now authoritative. Pinned by a test asserting the run writes nothing and returns 1.

On stacking this PR. Understood and noted for how this lands.

---

Copilot

check_ir_validity.py:181 — -O3 hides emission defects. Fixed. COMPILE_CFLAGS = ("-O0", "-nogpulib"), and _compile_argv() was extracted so a test can pin this gate and the arch-domain generator to the same flag.

This found more than it claimed. No verdicts changed at llvm20 or llvm22, but at llvm23 three gfx950 attention cases fail at -O0 and pass at both -O1 and -O3, while the same modules pass at -O0 on the other two flavors. The rejected construct is backend-selected MIR ($vgpr3 = V_MOV_B32_e32 $vgpr10_vgpr11), not IR rocke emits, so it reads as an llvm23 fast-regalloc issue rather than an emission defect. Tracking separately — flagged here because this comment is what surfaced it.

gen_arch_domain.py:761 — missing opt. Fixed; see @tenpercent's P2 above, same change.

gen_arch_domain.py:446 — signal termination classified as probe_error. Fixed, but not as suggested — the guarantee is there, the classification is not.

Clang installs its own SIGSEGV handler and prints the bug-report banner, so an ordinary crash already classifies as toolchain_crash through the text match. The genuinely uncovered case is SIGKILL — an OOM kill — which leaves empty stderr and a negative return code. Mapping every signal death to toolchain_crash would record "this machine ran out of memory" as "this toolchain crashes on this intrinsic": a property of the host committed as a fact about the compiler.

So instead, any cell still probe_error after the serial retry now fails the run, prints its diagnostic, and writes nothing. That covers signal death and every future unrecognised wording without the misattribution. All three full sweeps clear it — no column was refused.

test_arch_domain_artifact.py:160 — skipTest aborts the loop. I don't think this one holds; no change made.

skipTest does raise immediately, but it is raised inside with self.subTest(...), and unittest's subtest executor catches SkipTest (and AssertionError), records it against that subtest, and does not re-raise. Later columns are still checked. Confirmed deliberately, then again by accident: a rename mid-review broke this exact test, and all three flavor subtests reported independent failures rather than the run stopping at the first.

It is non-obvious enough to have misled a careful reader once, so the loop now carries a comment explaining why the skip does not abort it. Happy to reopen if you are seeing different behaviour on another unittest version.

multi_toolchain_strategy.md:360, arch_axis_proposal.md:305, gen_arch_domain.py:411 — stale cell count. Fixed in all three, taking the second option: the number is replaced by a description — every decl key × every wired arch, with the committed columns as the count of record — so it cannot drift again.

One correction to the finding: the count at the time was 166, not 167. The committed columns had drifted from the decl table in both directions — 3 stale keys and 2 unmeasured ones — which is precisely the failure the artifact gate exists to catch. All three columns are regenerated and now match the decl table exactly.

arch_axis_proposal.md:380 — KNOWN_BAD documented as empty. Fixed, and it was two places: the status table and the acceptance criterion both claimed empty. Both now record the 2 entries, and the criterion asks for no new failures beyond them.

run_all.py:192 — --only forwarded to two tools with different matching semantics. Fixed, taking your first option: run_all.py now has a separate --only-ir, and --only is no longer forwarded to the IR gate.

Investigating it turned up a sharper version than stated. mfma matches none of the 17 byte-identity families either, and checking all 17 against the corpus, every one has at least one case — so the path as described is not currently reachable. The reachable defect is that the two tools read an empty selection in opposite directions: run_diff filters to zero families, runs nothing, and reports green, while the IR gate calls it FATAL and exits 1. An ordinary typo therefore produced one vacuous green and one red. That asymmetry is also why the fix is a separate flag rather than silencing the FATAL — silencing it would make a typo'd partial run come back fully green having executed nothing.

check_ir_validity.py:278 — the flavor check never interrogates the compiler. Fixed. Worth stating what the existing check actually was: flavor != native compares two rocke-side values and ran before clang was even resolved, so the binary was never asked what it was. A complete LLVM 20 install on an llvm22 host passed every check and reported GREEN under a header reading flavor : llvm22.

The gate now prints clang --version unconditionally and compares the banner's major against the flavor the corpus was lowered at. On a mismatch it reports UNVALIDATED, deliberately rather than refusing: the generator writes a committed artifact where a mis-attributed run is a permanent false record, while this gate writes nothing — and since this PR turns it on by default, failing closed would newly red every host whose PATH clang disagrees with its comgr. --strict is the opt-in for CI. An unrecognised banner reads as unknown, never as mismatch, so a vendor rewording its version line cannot red the world.

The two helpers moved to a shared tools/_llvm_identity.py so the two tools can act differently on a mismatch without disagreeing about what a mismatch is, with a test asserting they hold the same function object.

gen_arch_domain.py:634 — immarg fallback records a probe defect as a target negative. Not changed, and I would welcome a second opinion.

The path exists exactly as described. But after regenerating all three columns, zero cells carry an immarg / non-immediate diagnostic at any status — the _IMMARG_PROBE_VALUES sweep resolves them before the fallback is reached. I held off because the change would ship untested, and because preserving probe_error now feeds the refusal gate added above, which converts a silently-wrong cell into a hard stop on the entire column. If a future vintage makes it reachable, that refusal fails loudly with the diagnostic printed rather than quietly recording arch_absent. Happy to make it a one-liner if you would rather close it now.

[cgmillette]

PR #12269 — measure per-GPU intrinsic legality + commit it · Verdict: 🟢 high-quality, 🔴 blocked on conflicts
(link gate already caught 3 dead declares + 2 broken corpus cases). ~16 prior findings addressed — not duplicated.
AICK-2272.

#	Sev	Location	Net-new finding
1	🔴	PR state	mergeable_state: dirty — conflicts; base of stacked #12441, mergeability coupled
2	🟡	drift gate / columns	Structural gate catches missing/stale keys but not wrong cells; only a host with that exact LLVM vintage can re-measure → ~17k committed "facts" are trust-based in normal CI
3	🟡	arch-domain artifact	17k data lines + drift gate are inert until consumer #12441 (stacked, unmerged) lands; only the link gate delivers value now
4	🟢	gen_arch_domain.py classifier	Diagnostic-wording list → each new LLVM vintage needs a code change or the refusal gate hard-fails that column (recurring tax)
5	🟢	immarg fallback (left-open item)	Concur with author's deferral: zero cells reach it; post-retry refusal gate backstops — not a blocker

Legend: 🔴 blocking · 🟠 should-fix · 🟡 minor-nit · 🟢 info/confirmed.

[assistant-librarian]

TheRock Submodule Bump Activity

Newest first

• 2026-10-07 — Included in TheRock via ROCm/TheRock#8777.