simdref 0.0.17__tar.gz → 0.0.19__tar.gz

{simdref-0.0.17/src/simdref.egg-info → simdref-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.17
+Version: 0.0.19
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later
@@ -177,7 +177,8 @@ Dev commands
 | Arm AARCHMRS (A64)      | Base instruction forms and operand tables               | live-only²          |
 | riscv-rvv-intrinsic-doc | RVV intrinsics with deterministic instruction refs      | 77,285 intrinsics   |
 | RISC-V unified-db       | RVV instruction forms, ISA tags, description, operation | 3,666 instructions  |
-| NVIDIA PTX ISA          | Instruction ops, syntax, qualifiers, versions, sm_XX    | 1,088 instructions  |
+| NVIDIA PTX ISA          | Instruction ops, syntax, qualifiers, versions, sm_XX    | 478 instructions    |
+| CUDA intrinsics         | Device intrinsics from clang CUDA headers               | 585 intrinsics      |
 | Intel Guide perf tables | Per-core latency and throughput                         | 9,134 rows          |
 | Intel Optimization Ref. | Latency and throughput tables (volume 2)                | 3,155 rows          |
 | InstLatX64              | Measured latency and throughput dumps                   | 16,235 rows         |

{simdref-0.0.17 → simdref-0.0.19}/README.md

@@ -142,7 +142,8 @@ Dev commands
 | Arm AARCHMRS (A64)      | Base instruction forms and operand tables               | live-only²          |
 | riscv-rvv-intrinsic-doc | RVV intrinsics with deterministic instruction refs      | 77,285 intrinsics   |
 | RISC-V unified-db       | RVV instruction forms, ISA tags, description, operation | 3,666 instructions  |
-| NVIDIA PTX ISA          | Instruction ops, syntax, qualifiers, versions, sm_XX    | 1,088 instructions  |
+| NVIDIA PTX ISA          | Instruction ops, syntax, qualifiers, versions, sm_XX    | 478 instructions    |
+| CUDA intrinsics         | Device intrinsics from clang CUDA headers               | 585 intrinsics      |
 | Intel Guide perf tables | Per-core latency and throughput                         | 9,134 rows          |
 | Intel Optimization Ref. | Latency and throughput tables (volume 2)                | 3,155 rows          |
 | InstLatX64              | Measured latency and throughput dumps                   | 16,235 rows         |

{simdref-0.0.17 → simdref-0.0.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simdref"
-version = "0.0.17"
+version = "0.0.19"
 description = "Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP."
 readme = "README.md"
 requires-python = ">=3.11"

{simdref-0.0.17 → simdref-0.0.19}/src/simdref/annotate.py

@@ -19,8 +19,17 @@ from typing import Any, Iterable, Iterator
 from simdref import perf
 from simdref.arm_instructions import _CONDITION_CODES
 from simdref.asm_identity import isa_by_acceptance
-from simdref.catkey import ISA_FAMILY, isa_family as _isa_family
-from simdref.lsp import NO_CATALOG_ROW, _document_arch, identity_keys
+from simdref.catkey import (
+    IMMEDIATE_ACCEPT,
+    ISA_FAMILY,
+    LITERAL_ACCEPT,
+    form_accept,
+    isa_family as _isa_family,
+    key_names_za_tile,
+    names_za_tile,
+    operands_of_key,
+)
+from simdref.lsp import NO_CATALOG_ROW, _classify_line, _document_arch, identity_keys
 from simdref.models import InstructionRecord
 from simdref.regtable import REG_TABLE, reg_rows
 from simdref.storage import load_instruction_from_db, load_instructions_by_mnemonic_from_db
@@ -471,7 +480,8 @@ def _asm_line(stripped: str, obj: _ObjdumpRecord | None, track_positions: bool)
         return AsmLine(LineKind.LABEL, stripped)
 
     head, comment = _split_comment(stripped)
-    m = _instr_head(head)
+    indent = head[: len(head) - len(head.lstrip())]
+    m = _instr_head(indent + _strip_prefix_tokens(head))
     if not m:
         return AsmLine(LineKind.COMMENT, stripped)
     return AsmLine(
@@ -616,6 +626,42 @@ def _voter_names():
 
 _EXCL_ARM, _SHARED, _RISCV = _voter_names()
 
+# The register families simdref supports: REG_TABLE also carries ARM32 spellings.
+_SUPPORTED_FAMILIES = frozenset({"x86", "a64", "riscv"})
+
+
+def _foreign_operands(operands: str) -> bool:
+    """True when the operands parse as no supported arch's operands.
+
+    A ``$``-sigil register (the MIPS/PPC spelling) belongs to no supported
+    arch, and a line whose register words all name unsupported families
+    (ARM32's r0-r15, ip, pc) carries no supported evidence. A word absent
+    from REG_TABLE is a symbol and stays neutral, and one supported-family
+    register anywhere clears the whole line (issue #65 B2/B6).
+    """
+    unsupported = sigil = False
+    i = 0
+    n = len(operands)
+    while i < n:
+        if not (operands[i] == "_" or operands[i].isalnum()):
+            i += 1
+            continue
+        j = i
+        while j < n and (operands[j] == "_" or operands[j].isalnum()):
+            j += 1
+        if i > 0 and operands[i - 1] == "$" and not operands[i].isdigit():
+            sigil = True
+        else:
+            families = {
+                family for _klass, _width, family in REG_TABLE.get(operands[i:j].casefold(), ())
+            }
+            if families & _SUPPORTED_FAMILIES:
+                return False
+            if families:
+                unsupported = True
+        i = j
+    return sigil or unsupported
+
 
 def _isa_votes(text: str) -> tuple[int, int, int]:
     """(excl_arm, excl_riscv, shared) register votes of one instruction text."""
@@ -630,7 +676,9 @@ def _isa_votes(text: str) -> tuple[int, int, int]:
         while j < n and (text[j] == "_" or text[j].isalnum()):
             j += 1
         token = text[i:j]
-        if i == 0 or text[i - 1] != "%":
+        # '%' starts an AT&T register and '$' a sigil register of no
+        # supported arch (MIPS/PPC): the name inside never votes (issue #65).
+        if i == 0 or text[i - 1] not in "%$":
             if token in _EXCL_ARM:
                 excl_arm += 1
             elif token in _SHARED:
@@ -1047,6 +1095,19 @@ def pick_record(
         # AT&T lists sources first; catalog form tokens are in Intel order.
         slots = list(reversed(slots))
 
+    # A ZA tile operand names the SME tile rows only, and a line without one
+    # never wants them (issue #65 M11): the rows share the mnemonic and
+    # operand count with the plain SVE/NEON forms, so operand shape alone
+    # picks a timed plain row where the ZA forms carry no timing. Same parity
+    # rule as the "_1to" broadcast filter in asm_identity.
+    za_pair = [
+        record
+        for record in candidates
+        if key_names_za_tile(str(getattr(record, "key", "") or "")) == names_za_tile(operands)
+    ]
+    if za_pair:
+        candidates = za_pair
+
     def score(rec: InstructionRecord) -> tuple[int, int, int, int]:
         measured = sum(
             1
@@ -1063,6 +1124,49 @@ def pick_record(
     return max(candidates, key=score)
 
 
+def _record_takes_line(record: InstructionRecord, operands: str) -> bool:
+    """Whether the record's key accepts the line's operand classes.
+
+    Classes and accepts come from the catalog: the lsp line classifier and
+    catkey's accept sets. A bare key constrains nothing, a literal key operand
+    (the zero-idiom rows) constrains nothing, and an input the classifier
+    gave no class constrains nothing. Register and memory classes ride each
+    other here exactly like the form pick, so the only hard mismatch is an
+    immediate input against a key operand that accepts no immediate: on an
+    undecided line that pick is a foreign borrow, not an answer (a bare
+    "1, 2, 3" never names a register-class row, issue #65 B2). A decided
+    line named its family already, so only the undecided line is judged.
+    """
+    ops = operands_of_key(record.key)
+    if not ops:
+        return True
+    arch, classes, _reverse, _weak = _classify_line(operands, False)
+    if arch:
+        # A decided line named its family; the family-pinned pick stands.
+        return True
+    if "%" in operands or "$" in operands:
+        # AT&T lists sources first and key operands are in Intel order, so
+        # the classes flip to meet the key (the rule pick_record's slots
+        # use). A sigil-less line keeps its order: Intel and ARM both name
+        # the destination first, as the key does.
+        classes = list(reversed(classes))
+    immediates = [cls for cls in classes if cls in ("i", "lit0", "lit1")]
+    if not immediates:
+        return True
+    if len(ops) != len(classes):
+        return False
+    for cls, op in zip(classes, ops):
+        accept = form_accept(op)
+        if (
+            cls in ("i", "lit0", "lit1")
+            and accept
+            and accept not in LITERAL_ACCEPT
+            and accept.isdisjoint(IMMEDIATE_ACCEPT)
+        ):
+            return False
+    return True
+
+
 # ---------------------------------------------------------------------------
 # Aggregation
 # ---------------------------------------------------------------------------
@@ -1439,12 +1543,15 @@ def _annotate_instruction(
     line_isa: str | None = None,
     line_number: int | None = None,
     identity_cache: dict[str, tuple[InstructionRecord, PerfSummary | None]] | None = None,
+    foreign: bool = False,
 ) -> tuple[str, dict[str, Any] | None]:
     """Return the rendered output line and an optional JSON record.
 
     ``line_isa`` names the family the line's own evidence shows (a pinned
     ``--isa`` counts as one). None marks a neutral line in auto mode: the
-    stream family answers first, then the family that holds rows.
+    stream family answers first, then the family that holds rows. ``foreign``
+    marks a line whose operands parse as no supported arch's operands
+    (PPC, MIPS, ARM32): no supported family's rows answer it (issue #65 B2/B6).
     """
     if stats is not None:
         stats["parsed"] = stats.get("parsed", 0) + 1
@@ -1509,7 +1616,9 @@ def _annotate_instruction(
     else:
         isa = line_isa or opts.isa
         pick_isa = isa
-        if lookup_cache is not None:
+        if foreign:
+            records = []
+        elif lookup_cache is not None:
             records = lookup_cache.get((parsed.mnemonic, isa))
             if records is None:
                 # Module-level call (not a captured reference) so tests can
@@ -1518,16 +1627,21 @@ def _annotate_instruction(
                 lookup_cache[(parsed.mnemonic, isa)] = records
         else:
             records = lookup(parsed.mnemonic, conn, isa=isa)
-        if not records and line_isa is None:
+        if not records and line_isa is None and not foreign:
             # A neutral line whose stream family holds no rows gets the rows
             # of the family that has them (issue #57 batch: jnle, bare b).
+            # A foreign line borrows nothing (issue #65 B2/B6).
             pick_isa = None
             records = lookup(parsed.mnemonic, conn, isa=None)
             if lookup_cache is not None:
                 lookup_cache[(parsed.mnemonic, None)] = records
-        if stats is not None and records:
-            stats["recognized"] = stats.get("recognized", 0) + 1
         record = pick_record(records, arch=opts.arch, operands=parsed.operands, isa=pick_isa)
+        if record is not None and not _record_takes_line(record, parsed.operands):
+            # The key does not take the line's operand classes: a foreign
+            # borrow, not an answer (issue #65 B2).
+            record = None
+        if stats is not None and record is not None:
+            stats["recognized"] = stats.get("recognized", 0) + 1
 
     if record is None:
         if opts.unknown == "drop":
@@ -1686,6 +1800,7 @@ def annotate_stream(
     }
     auto_isa = opts.isa not in ("x86", "arm", "riscv")
     line_family: dict[int, str] = {}
+    foreign: set[int] = set()
     if auto_isa:
         # Assembler acceptance decides each line's family: one llvm-mc run
         # per candidate triple. The register vote below is the fallback when
@@ -1693,6 +1808,13 @@ def annotate_stream(
         probe_texts = [text for _index, text in items]
         families, majority = isa_by_acceptance(probe_texts)
         line_family = {index: family for (index, _text), family in zip(items, families) if family}
+        # The line's own parse names foreign architectures (PPC/MIPS/ARM32):
+        # those lines borrow no rows from a supported family (issue #65 B2/B6).
+        foreign = {
+            index
+            for index, parsed in enumerate(parsed_lines)
+            if parsed.kind == LineKind.INSTRUCTION and _foreign_operands(parsed.operands)
+        }
         # auto: the acceptance majority names the ISA, then the input
         # signals, then the document arch from _document_arch; x86 stays
         # the guess when all stay silent.
@@ -1729,6 +1851,11 @@ def annotate_stream(
             if not collecting_json:
                 yield parsed.raw + "\n"
             continue
+        line_isa = opts.isa
+        if auto_isa:
+            # A pin forces one family; auto mode splits the batch per line,
+            # the assembler verdict first and the register vote as fallback.
+            line_isa = line_family.get(index) or _line_isa(f"{parsed.mnemonic} {parsed.operands}")
         out_line, record = _annotate_instruction(
             parsed,
             opts,
@@ -1736,13 +1863,10 @@ def annotate_stream(
             lookup_cache,
             stats,
             identity_key=identity.get(index),
-            # A pin forces one family; auto mode splits the batch per line,
-            # the assembler verdict first and the register vote as fallback.
-            line_isa=opts.isa
-            if not auto_isa
-            else line_family.get(index) or _line_isa(f"{parsed.mnemonic} {parsed.operands}"),
+            line_isa=line_isa,
             line_number=index + 1,
             identity_cache=identity_cache,
+            foreign=index in foreign if line_isa is None else False,
         )
         if collecting_json:
             if record is not None:

{simdref-0.0.17 → simdref-0.0.19}/src/simdref/asm_identity.py

@@ -1403,6 +1403,40 @@ _ISA_CANDIDATES = (
 )
 
 
+def _reloc_branch_targets(text: str) -> str:
+    """Spell objdump's bare branch targets the fixup way ("je 7f37b" as ".+0x7f37b").
+
+    objdump prints branch targets as bare hex, and llvm-mc rejects the bare
+    spelling where the value holds an a-f letter: "7f37b" is no decimal
+    number and no valid symbol. The ".+0x" spelling is the same PC-relative
+    fixup the <sym> form answers with, and it carries no immediate range
+    check, so it assembles on every candidate triple for any address. A
+    token qualifies only when it starts with a digit, holds only hex digits
+    with at least one a-f letter (a decimal immediate assembles as-is), and
+    follows a separator, so the tail of "0x...", "0b..." or "#0x..." text is
+    never rewritten.
+    """
+    hexd = "0123456789abcdefABCDEF"
+    letters = "abcdefABCDEF"
+    out: list[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        if text[i].isdigit() and (i == 0 or text[i - 1] in " \t,"):
+            j = i
+            while j < n and text[j] in hexd:
+                j += 1
+            token = text[i:j]
+            if any(c in letters for c in token):
+                out.append(".+0x")
+            out.append(token)
+            i = j
+            continue
+        out.append(text[i])
+        i += 1
+    return "".join(out)
+
+
 def _probe_all_triples(lines: list[str], llvm_mc: str) -> dict[tuple[str, str], list[dict]]:
     """Probe every candidate triple, one llvm-mc run per triple.
 
@@ -1412,6 +1446,7 @@ def _probe_all_triples(lines: list[str], llvm_mc: str) -> dict[tuple[str, str],
     """
     from concurrent.futures import ThreadPoolExecutor
 
+    lines = [_reloc_branch_targets(line) for line in lines]
     with ThreadPoolExecutor(max_workers=len(_ISA_CANDIDATES)) as pool:
         futures = {
             (arch, syntax): pool.submit(_probe_lines_split, lines, arch, syntax, llvm_mc)

{simdref-0.0.17 → simdref-0.0.19}/src/simdref/asmline.py

@@ -174,28 +174,96 @@ def c_asm_zone_at(text: str, offset: int) -> str | None:
 
     'template' is an asm(...) template string, 'msvc' an MSVC __asm block
     or line, 'operands' the operand and clobber lists after the first ':'
-    of an asm(...) call. None is plain code. Shares _asm_call_at with
+    of an asm(...) call, 'comment' a C comment, 'string' a string literal
+    that is no asm template. None is plain code. Shares _asm_call_at with
     c_asm_literals, so hover and completion parse the same calls.
     """
+    span = c_span_at(text, offset)
+    if span == "comment":
+        return span
+    zone = c_asm_zone_span_at(text, offset)
+    return zone[0] if zone is not None else span
+
+
+def c_asm_zone_span_at(text: str, offset: int) -> tuple[str, int, int] | None:
+    """(kind, low, high) of the asm zone holding the offset, or None.
+
+    The same walk as c_asm_zone_at. lsp.py reads the bounds: each MSVC
+    __asm statement starts at its own zone's low bound.
+    """
     masked = _mask_c_comments(text)
     index = 0
     while index < len(masked):
         hit = _asm_call_at(masked, index)
         if hit is not None:
             block_end, literals, zones = hit
-            for kind, low, high in zones:
-                if low <= offset <= high:
-                    return kind
-            for start, _body in literals:
-                if start <= offset <= start + len(_body):
-                    return "template"
+            for zone in zones:
+                if zone[1] <= offset <= zone[2]:
+                    return zone
+            for start, body in literals:
+                if start <= offset <= start + len(body):
+                    return "template", start, start + len(body)
             index = block_end
         else:
             index += 1
     return None
 
 
+def c_span_at(text: str, offset: int) -> str | None:
+    """'comment' or 'string' when a cursor offset sits inside one, else None.
+
+    Same scan as _mask_c_comments. A cursor right after the opening
+    delimiter is inside; a cursor after the closing one is outside. An
+    unterminated block comment runs to the end, an unterminated string to
+    the end of its line: both are still being typed. A char literal and a
+    raw string are their own tokens: the double quote inside the char
+    literal '"' never opens a string, and a raw string keeps its quotes.
+    """
+    index = 0
+    while index < offset:
+        line_end = text.find("\n", index)
+        line_end = len(text) if line_end == -1 else line_end
+        if text[index] == "'":
+            end = _char_end(text, index) or line_end + 1
+            if index < offset < end:
+                return "string"
+        elif text[index] == '"':
+            end = _raw_string_end(text, index)
+            if end is None:
+                end = _string_end(text, index) or line_end + 1
+            if index < offset < end:
+                return "string"
+        elif text.startswith("//", index):
+            end = line_end
+            if index + 2 <= offset <= end:
+                return "comment"
+        elif text.startswith("/*", index):
+            close = text.find("*/", index + 2)
+            end = len(text) if close == -1 else close + 2
+            if index + 2 <= offset <= (end if close == -1 else close):
+                return "comment"
+        else:
+            index += 1
+            continue
+        index = max(end, index + 1)
+    return None
+
+
 _QUALIFIERS = ("volatile", "__volatile__", "goto", "inline")
+_ASM_KEYWORDS = ("__asm__", "__asm", "asm")
+
+
+def _asm_keyword_at(text: str, index: int) -> str | None:
+    """The asm keyword at index with word boundaries on both sides, or None."""
+    if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):
+        return None
+    for keyword in _ASM_KEYWORDS:
+        if text.startswith(keyword, index):
+            after = index + len(keyword)
+            tail = text[after : after + 1]
+            if not (tail.isalnum() or tail == "_"):
+                return keyword
+    return None
 
 
 def _asm_call_at(
@@ -214,7 +282,7 @@ def _asm_call_at(
         and (text[index - 1].isalnum() or text[index - 1] == "_")
     ):
         return None
-    for keyword in ("__asm__", "__asm", "asm"):
+    for keyword in _ASM_KEYWORDS:
         if text.startswith(keyword, index):
             break
     else:
@@ -240,9 +308,12 @@ def _asm_call_at(
             return None
         return close + 1, [], [("msvc", cursor + 1, close)]
     if text[cursor : cursor + 1] != "(":
-        # MSVC __asm <insn> line: the instruction runs to end of line.
-        end = index
+        # MSVC __asm <insn>: the statement runs to end of line, or to the
+        # next __asm keyword, which starts its own statement on the row.
+        end = cursor
         while end < len(text) and text[end] != "\n":
+            if _asm_keyword_at(text, end):
+                break
             end += 1
         return end, [], [("msvc", cursor, end)]
     cursor = _skip_space(text, cursor + 1)
@@ -353,14 +424,63 @@ def _string_end(text: str, index: int, spans_lines: bool = False) -> int | None:
     return None
 
 
+def _char_end(text: str, index: int) -> int | None:
+    """The index after the closing quote of the char literal at index, or None.
+
+    A char literal is one token like a string: its quote never opens a
+    string, and an escape pair ("\\'", "\\"") counts as one character.
+    """
+    if text[index : index + 1] != "'":
+        return None
+    cursor = index + 1
+    while cursor < len(text):
+        char = text[cursor]
+        if char == "\\":
+            cursor += 2
+        elif char == "'":
+            return cursor + 1
+        elif char == "\n":
+            return None
+        else:
+            cursor += 1
+    return None
+
+
+def _raw_string_end(text: str, index: int) -> int | None:
+    """The index after the R"delim(...)delim" raw string whose quote is at index.
+
+    None when the shape is not a raw string: the caller then reads the
+    quote as a plain string. An unterminated raw string runs one past the
+    end of the text, because its body spans lines.
+    """
+    if text[index - 1 : index] != "R":
+        return None
+    open_paren = text.find("(", index + 1, index + 18)
+    if open_paren == -1:
+        return None
+    delim = text[index + 1 : open_paren]
+    if len(delim) > 16 or any(char.isspace() or char in "()\\" for char in delim):
+        return None
+    close = text.find(")" + delim + '"', open_paren + 1)
+    return len(text) + 1 if close == -1 else close + len(delim) + 2
+
+
 def _mask_c_comments(text: str) -> str:
-    """Blank C comments to spaces (newlines stay). String literals stay."""
+    """Blank C comments to spaces (newlines stay). Literal tokens stay."""
     out: list[str] = []
     index = 0
     while index < len(text):
         char = text[index]
+        if char == "'":
+            end = _char_end(text, index)
+            if end is not None:
+                out.append(text[index:end])
+                index = end
+                continue
         if char == '"':
-            end = _string_end(text, index)
+            end = _raw_string_end(text, index)
+            if end is None:
+                end = _string_end(text, index)
             if end is not None:
                 out.append(text[index:end])
                 index = end

{simdref-0.0.17 → simdref-0.0.19}/src/simdref/catkey.py

@@ -68,6 +68,7 @@ ISA_FAMILY = {
     "riscv32": "riscv",
     "riscv64": "riscv",
     "ptx": "ptx",
+    "cuda": "cuda",
 }
 
 
@@ -84,6 +85,8 @@ def isa_family(architecture: str | None) -> str | None:
         return "riscv"
     if name.startswith("ptx"):
         return "ptx"
+    if name.startswith("cuda"):
+        return "cuda"
     return "x86"
 
 
@@ -150,6 +153,35 @@ def _first_digits(text: str) -> int | None:
     return int(text[start:end]) if end > start else None
 
 
+def names_za_tile(text: str) -> bool:
+    """True when *text* names a ZA tile operand ("za0h", "za.s"), never ZT0.
+
+    A ZA tile name starts with "za" at an operand boundary and closes the
+    stem with a tile digit ("za0h"), a tile element letter ("zab") or the
+    full-register dot ("za.s"). One boundary scan; no regular expressions.
+    """
+    low = text.casefold()
+    for at in range(len(low) - 2):
+        if low[at] != "z" or low[at + 1] != "a":
+            continue
+        if at > 0 and (low[at - 1].isalnum() or low[at - 1] in "._"):
+            continue
+        if low[at + 2].isdecimal() or low[at + 2] in ".bhwdq":
+            return True
+    return False
+
+
+def key_names_za_tile(key: str) -> bool:
+    """True when a catalog key names a ZA tile operand form.
+
+    The tile encodes as a placeholder ("<ZAT...>"), the tile-slice register
+    ("<WV>") or a literal name ("ZA0<HV>"). ZT0 rows stay out: SVE counted
+    register-list keys reuse "<ZT..>" placeholder names for plain Z lists.
+    """
+    upper = key.upper()
+    return "<ZA" in upper or "<WV>" in upper or names_za_tile(key)
+
+
 def form_accept(op: str) -> frozenset:
     """The line classes a catalog-key operand accepts, as one frozenset.
 
@@ -200,8 +232,10 @@ def form_accept(op: str) -> frozenset:
     name = _cut_key_repeats(op.upper())
     if "<HASH>" in name:
         return IMMEDIATE_ACCEPT
-    # A ZA tile operand ("<ZAT...>[W1, #0]") is not a plain vector register.
-    if "<ZAT" in name:
+    # A ZA tile operand ("<ZAT...>[W1, #0]", "ZA0<HV>.B[W1, #0]",
+    # "Z3.4S[<WV>, #0]") is not a plain vector register: it matches a line's
+    # ZA tile operand only.
+    if key_names_za_tile(op):
         return frozenset({"za"})
     if _is_counted_vector(name):
         # A counted register list accepts only the same count.

simdref-0.0.19/src/simdref/cuda.py

@@ -0,0 +1,50 @@
+"""CUDA C++ device intrinsics parsing and derived record rows.
+
+Parses the JSON bundle produced by tools/vendor_cuda_sources.py, which
+extracts CUDA API names from four clang headers and resolves PTX
+instruction links by parsing LLVM TableGen .td files.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from simdref.models import IntrinsicRecord
+
+BUNDLE_FORMAT = "clang-cuda-headers-v2"
+CUDA_INTRINSICS_DOC_URL = "https://docs.nvidia.com/cuda/cuda-c-programming-guide/"
+
+
+def parse_cuda_intrinsics_payload(text: str) -> list[IntrinsicRecord]:
+    """Parse the CUDA intrinsics JSON bundle into IntrinsicRecord rows."""
+    data = json.loads(text)
+    if data.get("format") != BUNDLE_FORMAT:
+        raise ValueError(f"Unexpected bundle format: {data.get('format')!r}")
+
+    rows: list[IntrinsicRecord] = []
+    for item in data.get("intrinsics", []):
+        metadata = item.get("metadata", {})
+        classification = metadata.get("classification", "")
+
+        row = IntrinsicRecord(
+            name=item["name"],
+            signature=item.get("signature", ""),
+            description=item.get("description", ""),
+            header=item.get("header", ""),
+            url=item.get("url", ""),
+            architecture="cuda",
+            isa=["CUDA"],
+            category=item.get("category", ""),
+            subcategory=item.get("subcategory", ""),
+            instructions=item.get("instructions", []),
+            instruction_refs=item.get("instruction_refs", []),
+            metadata={"classification": classification},
+            doc_sections=item.get("doc_sections", {}),
+            notes=item.get("notes", []),
+            aliases=item.get("aliases", []),
+            source="clang-cuda-headers",
+        )
+        rows.append(row)
+
+    return rows