simdref 0.0.13__tar.gz → 0.0.15__tar.gz

{simdref-0.0.13/src/simdref.egg-info → simdref-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.13
+Version: 0.0.15
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later
@@ -28,6 +28,7 @@ Requires-Dist: PyMuPDF<2,>=1.28
 Requires-Dist: PyYAML<7,>=6.0.3
 Requires-Dist: rapidfuzz<4,>=3.14
 Requires-Dist: rich<16,>=15
+Requires-Dist: simdref-llvm-mc==23.1.4; (sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or (sys_platform == "darwin" and (platform_machine == "arm64" or platform_machine == "x86_64")) or (sys_platform == "win32" and platform_machine == "AMD64")
 Requires-Dist: textual<9,>=8.2
 Requires-Dist: typer<1,>=0.27
 Dynamic: license-file
@@ -106,7 +107,7 @@ simdref-lsp
 
 Editor clients, one for each editor:
 
-- Zed: [zed-simdref](https://github.com/simd-labs/zed-simdref)
+- Zed: [zed-asm-intrinsics](https://github.com/simd-labs/zed-asm-intrinsics)
 - VS Code: [vscode-simdref](https://github.com/simd-labs/vscode-simdref)
 - JetBrains: [jetbrains-simdref](https://github.com/simd-labs/jetbrains-simdref)
 - Neovim: [nvim-simdref](https://github.com/simd-labs/nvim-simdref)

{simdref-0.0.13 → simdref-0.0.15}/README.md

@@ -72,7 +72,7 @@ simdref-lsp
 
 Editor clients, one for each editor:
 
-- Zed: [zed-simdref](https://github.com/simd-labs/zed-simdref)
+- Zed: [zed-asm-intrinsics](https://github.com/simd-labs/zed-asm-intrinsics)
 - VS Code: [vscode-simdref](https://github.com/simd-labs/vscode-simdref)
 - JetBrains: [jetbrains-simdref](https://github.com/simd-labs/jetbrains-simdref)
 - Neovim: [nvim-simdref](https://github.com/simd-labs/nvim-simdref)

{simdref-0.0.13 → simdref-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simdref"
-version = "0.0.13"
+version = "0.0.15"
 description = "Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -41,6 +41,11 @@ dependencies = [
   "PyYAML>=6.0.3,<7",
   "rapidfuzz>=3.14,<4",
   "rich>=15,<16",
+  # Pinned to the LLVM the catalog build used. Wheels exist only for
+  # manylinux x86_64 aarch64, macOS arm64 x86_64 and win_amd64, so the
+  # marker keeps the dependency off every other platform (musl included),
+  # where pip must see no candidate instead of failing to resolve.
+  'simdref-llvm-mc==23.1.4; (sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or (sys_platform == "darwin" and (platform_machine == "arm64" or platform_machine == "x86_64")) or (sys_platform == "win32" and platform_machine == "AMD64")',
   "textual>=8.2,<9",
   "typer>=0.27,<1",
 ]

{simdref-0.0.13 → simdref-0.0.15}/src/simdref/annotate.py

@@ -17,8 +17,9 @@ from enum import Enum
 from typing import Any, Iterable, Iterator
 
 from simdref import perf
+from simdref.lsp import NO_CATALOG_ROW, identity_keys
 from simdref.models import InstructionRecord
-from simdref.storage import load_instructions_by_mnemonic_from_db
+from simdref.storage import load_instruction_from_db, load_instructions_by_mnemonic_from_db
 
 
 class LineKind(str, Enum):
@@ -410,6 +411,9 @@ def _operand_match_score(
     return score
 
 
+# shortcut: the form pick answers only when byte identity has no row
+# (schema-13 catalogs or missing tools); remove it at the schema-14 data
+# release with simdref-llvm-mc on PyPI as a required dependency
 def pick_record(
     records: list[InstructionRecord],
     *,
@@ -456,7 +460,9 @@ class PerfSummary:
 def _per_arch_value(details: dict[str, Any], value_fn) -> float | None:
     for v in value_fn(details):
         try:
-            return float(v)
+            # Latency ranges render as "min-max" strings (simdref#50); the
+            # float view takes the min so aggregates stay numeric.
+            return float(str(v).split("-", 1)[0])
         except (TypeError, ValueError):
             continue
     return None
@@ -679,22 +685,48 @@ def _annotate_instruction(
     conn: sqlite3.Connection,
     lookup_cache: dict[str, list[InstructionRecord]] | None = None,
     stats: dict[str, int] | None = None,
+    identity_key: str | None = None,
 ) -> tuple[str, dict[str, Any] | None]:
     """Return the rendered output line and an optional JSON record."""
-    if lookup_cache is not None:
-        records = lookup_cache.get(parsed.mnemonic)
-        if records is None:
-            # Module-level call (not a captured reference) so tests can
-            # keep monkeypatching ``annotate.lookup`` with a 2-arg fake.
-            records = lookup(parsed.mnemonic, conn)
-            lookup_cache[parsed.mnemonic] = records
-    else:
-        records = lookup(parsed.mnemonic, conn)
     if stats is not None:
         stats["parsed"] = stats.get("parsed", 0) + 1
-        if records:
+    if identity_key == NO_CATALOG_ROW:
+        # Byte identity identified the form and the catalog has no row for
+        # it (issue #49: uops.info carries no AVX reg-reg VMOVAPD/VMOVUPS):
+        # report the miss by name, never guess a neighbour form below.
+        if stats is not None:
+            stats["no_row"] = stats.get("no_row", 0) + 1
+        no_row: dict[str, Any] = {
+            "mnemonic": parsed.mnemonic,
+            "known": False,
+            "no_measured_row": True,
+        }
+        if parsed.address is not None:
+            no_row["address"] = f"0x{parsed.address:x}"
+        if parsed.source_file:
+            no_row["source_file"] = parsed.source_file
+        if parsed.source_line is not None:
+            no_row["source_line"] = parsed.source_line
+        return f"{parsed.raw}   # {parsed.mnemonic}: no measured row", no_row
+    # Byte identity wins over the form pick: the record is what the line
+    # assembles to, and an empty row keeps the old pick unchanged.
+    record = load_instruction_from_db(conn, identity_key) if identity_key else None
+    if record is not None:
+        if stats is not None:
+            stats["recognized"] = stats.get("recognized", 0) + 1
+    else:
+        if lookup_cache is not None:
+            records = lookup_cache.get(parsed.mnemonic)
+            if records is None:
+                # Module-level call (not a captured reference) so tests can
+                # keep monkeypatching ``annotate.lookup`` with a 2-arg fake.
+                records = lookup(parsed.mnemonic, conn)
+                lookup_cache[parsed.mnemonic] = records
+        else:
+            records = lookup(parsed.mnemonic, conn)
+        if stats is not None and records:
             stats["recognized"] = stats.get("recognized", 0) + 1
-    record = pick_record(records, arch=opts.arch, operands=parsed.operands)
+        record = pick_record(records, arch=opts.arch, operands=parsed.operands)
 
     if record is None:
         if opts.unknown == "drop":
@@ -784,8 +816,29 @@ def annotate_stream(
     pending_src_line: int | None = None
     lookup_cache: dict[str, list[InstructionRecord]] = {}
 
-    for line in lines:
-        parsed = parse_asm_line(line, track_positions=opts.track_positions)
+    parsed_lines = [parse_asm_line(line, track_positions=opts.track_positions) for line in lines]
+    # One llvm-mc run for the whole input: byte identity per instruction
+    # line. An objdump line assembles as its mnemonic and operands only, so
+    # the address and byte columns never reach the assembler.
+    items = [
+        (
+            index,
+            f"{parsed.mnemonic} {parsed.operands}".strip()
+            if parsed.address is not None
+            else parsed.raw,
+        )
+        for index, parsed in enumerate(parsed_lines)
+        if parsed.kind == LineKind.INSTRUCTION
+    ]
+    identity = {
+        index: key
+        for (index, _text), key in zip(
+            items, identity_keys([text for _index, text in items], None, conn)
+        )
+        if key
+    }
+
+    for index, parsed in enumerate(parsed_lines):
         if opts.track_positions:
             if parsed.kind == LineKind.INSTRUCTION:
                 parsed.source_file = pending_src_file
@@ -815,7 +868,9 @@ def annotate_stream(
             if not collecting_json:
                 yield parsed.raw + "\n"
             continue
-        out_line, record = _annotate_instruction(parsed, opts, conn, lookup_cache, stats)
+        out_line, record = _annotate_instruction(
+            parsed, opts, conn, lookup_cache, stats, identity_key=identity.get(index)
+        )
         if collecting_json:
             if record is not None:
                 json_records.append(record)

{simdref-0.0.13 → simdref-0.0.15}/src/simdref/arm_instructions.py

@@ -256,6 +256,18 @@ def _candidate_instruction_lists(payload: Any) -> list[list[dict[str, Any]]]:
     return lists
 
 
+def _is_aarchmrs_tree(payload: Any) -> bool:
+    top = payload.get("instructions") if isinstance(payload, dict) else None
+    return (
+        isinstance(top, list)
+        and bool(top)
+        and all(
+            isinstance(node, dict) and str(node.get("_type", "")).endswith("InstructionSet")
+            for node in top
+        )
+    )
+
+
 def _records_from_payload(payload: Any) -> list[InstructionRecord]:
     if isinstance(payload, dict) and payload.get("format") == "arm-aarchmrs-instructions-v1":
         instructions_json = str(payload.get("instructions_json") or "[]")
@@ -264,9 +276,8 @@ def _records_from_payload(payload: Any) -> list[InstructionRecord]:
     if isinstance(payload, dict) and payload.get("format") == "arm-instructions-fixture-v1":
         return _records_from_payload(payload.get("instructions") or [])
 
-    aarchmrs = _records_from_aarchmrs_tree(payload)
-    if aarchmrs:
-        return aarchmrs
+    if _is_aarchmrs_tree(payload):
+        return _records_from_aarchmrs_tree(payload)
 
     for candidates in _candidate_instruction_lists(payload):
         records = [_normalize_instruction_item(item) for item in candidates]
@@ -280,6 +291,44 @@ def _records_from_payload(payload: Any) -> list[InstructionRecord]:
 # AARCHMRS (official Arm machine-readable spec) tree walker
 # ---------------------------------------------------------------------------
 
+
+def _encodeset_mask_match(encoding: Any) -> tuple[int, int, int] | None:
+    """Return (bits, mask, match) for an AARCHMRS encodeset, or None.
+
+    Every encodeset entry value with a fixed '0'/'1' pattern adds mask and
+    match bits; 'x' entries (operand fields) add nothing. An entry with a
+    non-binary value or a length that disagrees with its range makes the
+    whole encodeset unusable as a key.
+    """
+    if not isinstance(encoding, dict):
+        return None
+    width = encoding.get("width")
+    values = encoding.get("values")
+    if width != 32 or not isinstance(values, list):
+        return None
+    mask = match = 0
+    for entry in values:
+        if not isinstance(entry, dict):
+            return None
+        value = str(((entry.get("value") or {}).get("value")) or "").strip("'")
+        rng = entry.get("range") or {}
+        start, field_width = rng.get("start"), rng.get("width")
+        if not isinstance(start, int) or not isinstance(field_width, int):
+            return None
+        if len(value) != field_width:
+            return None
+        for i, char in enumerate(value):
+            bit = start + field_width - 1 - i
+            if char == "x":
+                continue
+            if char not in "01":
+                return None
+            mask |= 1 << bit
+            if char == "1":
+                match |= 1 << bit
+    return 32, mask, match
+
+
 _RULE_PLACEHOLDER: dict[str, str] = {
     # Scalar
     "Xd": "x0",
@@ -311,6 +360,13 @@ _RULE_PLACEHOLDER: dict[str, str] = {
     "Dn": "d1",
     "Dm": "d2",
     "Da": "d3",
+    # FP accumulator register operands; t/s letters follow the Xt/Xs numbering.
+    "fpfar_dt": "d0",
+    "fpfar_ds": "d1",
+    "fpfar_st": "s0",
+    "fpfar_ss": "s1",
+    "fpfar_ht": "h0",
+    "fpfar_hs": "h1",
     "Sd": "s0",
     "Sn": "s1",
     "Sm": "s2",
@@ -451,11 +507,16 @@ def _records_from_aarchmrs_tree(payload: Any) -> list[InstructionRecord]:
         return []
 
     records: list[InstructionRecord] = []
-    seen_keys: set[tuple[str, str]] = set()
+    seen_keys: dict[tuple[str, str], tuple[int, int]] = {}
 
     def walk(node: dict[str, Any], group_path: list[str]) -> None:
         node_type = str(node.get("_type", ""))
         if node_type.endswith("Instruction"):
+            enc = _encodeset_mask_match(node.get("encoding"))
+            if enc is None:
+                enc_bits = enc_mask = enc_match = 0
+            else:
+                enc_bits, enc_mask, enc_match = enc
             assembly = node.get("assembly")
             if not isinstance(assembly, dict):
                 return
@@ -463,15 +524,25 @@ def _records_from_aarchmrs_tree(payload: Any) -> list[InstructionRecord]:
             if not rendered:
                 return
             head, _, tail = rendered.partition(" ")
-            mnemonic = head.strip().upper()
-            if not mnemonic or not re.match(r"^[A-Z][A-Z0-9]*$", mnemonic):
+            # Head tokens can glue a literal or rule placeholder onto the
+            # mnemonic (RET<Rn_option>, DCPS1#0, B.<cond_option>): take the
+            # leading alphanumeric run instead of dropping the whole node.
+            mnemonic_match = re.match(r"[A-Z][A-Z0-9]*", head.strip().upper())
+            if not mnemonic_match:
                 return
+            mnemonic = mnemonic_match.group(0)
             operand_form = tail.strip()
             form = _canonical_instruction_key(mnemonic, operand_form) if operand_form else mnemonic
             key = (mnemonic, form.casefold())
-            if key in seen_keys:
-                return
-            seen_keys.add(key)
+            seen_enc = seen_keys.get(key)
+            if seen_enc is not None:
+                if seen_enc == (enc_mask, enc_match):
+                    return
+                # Sibling encodings of one rendered form stay separate rows;
+                # their keys are never merged (spec K4).
+                form = f"{form} [{str(node.get('name') or '').strip()}]"
+                key = (mnemonic, form.casefold())
+            seen_keys[key] = (enc_mask, enc_match)
             summary = _generated_summary(mnemonic)
             if not summary.endswith("."):
                 summary += "."
@@ -490,6 +561,9 @@ def _records_from_aarchmrs_tree(payload: Any) -> list[InstructionRecord]:
                     isa=_infer_aarchmrs_isa(group_path),
                     metadata=metadata,
                     source="arm-a64",
+                    enc_bits=enc_bits,
+                    enc_mask=enc_mask,
+                    enc_match=enc_match,
                 )
             )
             return
@@ -503,8 +577,15 @@ def _records_from_aarchmrs_tree(payload: Any) -> list[InstructionRecord]:
                 walk(child, next_path)
 
     for top_node in top:
-        if isinstance(top_node, dict):
-            walk(top_node, [str(top_node.get("name") or "")])
+        if not isinstance(top_node, dict):
+            continue
+        set_name = str(top_node.get("name") or "")
+        # A32/T32 encodings cannot be scoped from a bare word (their patterns
+        # overlap A32 condition space), and the byte key is defined on the A64
+        # instruction set only (spec K2/K4).
+        if set_name != "A64":
+            continue
+        walk(top_node, [set_name])
     return records