feat(backends): add QEMU generator for RISC-V instruction set

- Implement a generator that generates insn32.decode for qemu.
- Move load_full_instructions to generator.py so that other generators
  can use it.

Resolves issue: #1255

Author: AnimeshAgarwal28

backends/generators/binutils/binutils_generator.py

@@ -10,12 +10,14 @@
 import sys
 import argparse
 import logging
-import yaml
-import glob
 
 # Add parent directory to path to find generator.py
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from generator import parse_match, parse_extension_requirements
+from generator import (
+    parse_match,
+    parse_extension_requirements,
+    load_full_instructions,
+)
 from naming_config import USER_DEFINED_INSN_NAMES, USER_DEFINED_OPERAND_PREFERENCES, is_user_defined_class
 import re
 
@@ -220,43 +222,6 @@ def _map_single_operand(self, operand, variables, instr_info):
         return f"NON_DEFINED_{operand}"
 
 
-def load_full_instructions(inst_dir, enabled_extensions, include_all, target_arch):
-    instructions = {}
-    if enabled_extensions is None:
-        enabled_extensions = []
-    yaml_files = glob.glob(os.path.join(inst_dir, "**/*.yaml"), recursive=True)
-    logging.info(f"Found {len(yaml_files)} instruction files in {inst_dir}")
-    for yaml_file in yaml_files:
-        try:
-            with open(yaml_file, 'r', encoding='utf-8') as f:
-                data = yaml.safe_load(f)
-            if not isinstance(data, dict) or data.get('kind') != 'instruction':
-                continue
-            name = data.get('name')
-            if not name:
-                continue
-            defined_by = data.get('definedBy')
-            if not include_all and defined_by:
-                try:
-                    meets_req = parse_extension_requirements(defined_by)
-                    if not meets_req(enabled_extensions):
-                        logging.debug(f"Skipping {name} - extension requirements not met")
-                        continue
-                except Exception as e:
-                    logging.debug(f"Error parsing extension requirements for {name}: {e}")
-                    continue
-            encoding = data.get('encoding', {})
-            if target_arch in ['RV32', 'RV64'] and target_arch in encoding:
-                arch_encoding = encoding[target_arch]
-                data['encoding'] = arch_encoding
-            instructions[name] = data
-        except Exception as e:
-            logging.error(f"Error loading {yaml_file}: {e}")
-            continue
-    logging.info(f"Loaded {len(instructions)} instructions after filtering")
-    return instructions
-
-
 def generate_binutils_opcodes(instr_dict, output_file="riscv-opc.c", extension_mapper=None, binutils_path=None):
     operand_mapper = OperandMapper(binutils_path)
     if extension_mapper is None:

backends/generators/generator.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import os
+import glob
 import yaml
 import logging
 import pprint
@@ -281,6 +282,79 @@ def load_instructions(
     return instr_dict
 
 
+def load_full_instructions(inst_dir, enabled_extensions, include_all=False, target_arch="RV64"):
+    """Load full instruction metadata, optionally filtering by extensions and architecture.
+
+    Parameters
+    ----------
+    inst_dir : str
+        Root directory containing instruction YAML files.
+    enabled_extensions : list[str]
+        Extensions that should be considered enabled when filtering instructions.
+    include_all : bool, optional
+        When True, skip extension filtering entirely.
+    target_arch : str, optional
+        Target architecture selector: "RV32", "RV64", or "BOTH". When a YAML file
+        provides per-architecture encodings, the matching entry is selected.
+
+    Returns
+    -------
+    dict[str, dict]
+        Mapping from instruction name to the loaded YAML data (with a resolved
+        ``encoding`` section for the requested architecture).
+    """
+
+    instructions = {}
+    ext_filter = [] if enabled_extensions is None else enabled_extensions
+
+    yaml_files = glob.glob(os.path.join(inst_dir, "**/*.yaml"), recursive=True)
+    logging.info("Found %d instruction files in %s", len(yaml_files), inst_dir)
+
+    for yaml_file in yaml_files:
+        try:
+            with open(yaml_file, "r", encoding="utf-8") as fh:
+                data = yaml.safe_load(fh)
+
+            if not isinstance(data, dict) or data.get("kind") != "instruction":
+                continue
+
+            name = data.get("name")
+            if not name:
+                continue
+
+            defined_by = data.get("definedBy")
+            if not include_all and defined_by:
+                try:
+                    meets_req = parse_extension_requirements(defined_by)
+                    if not meets_req(ext_filter):
+                        logging.debug(
+                            "Skipping %s - extension requirements not met", name
+                        )
+                        continue
+                except Exception as exc:  # pragma: no cover - logging path only
+                    logging.debug(
+                        "Error parsing extension requirements for %s: %s",
+                        name,
+                        exc,
+                    )
+                    continue
+
+            encoding = data.get("encoding", {})
+            if target_arch in ("RV32", "RV64") and isinstance(encoding, dict):
+                arch_encoding = encoding.get(target_arch)
+                if arch_encoding:
+                    data["encoding"] = arch_encoding
+
+            instructions[name] = data
+
+        except Exception as exc:  # pragma: no cover - logging path only
+            logging.error("Error loading %s: %s", yaml_file, exc)
+            continue
+
+    logging.info("Loaded %d instructions after filtering", len(instructions))
+    return instructions
+
+
 def load_csrs(csr_root, enabled_extensions, include_all=False, target_arch="RV64"):
     """
     Recursively walk through csr_root, load YAML files that define a CSR,

backends/generators/qemu/README.md

@@ -0,0 +1,21 @@
+# QEMU generator
+
+## Usage
+
+```sh
+python3 generate_insn32_decode.py \
+  --inst-dir ../../../spec/std/isa/inst/ \
+  --extensions I,Zicsr \
+  --arch RV64 \
+  --output ./insn32.snippet
+```
+
+Arguments:
+
+- `--extensions` – comma-separated list of enabled extensions. Use
+  `--include-all` to bypass filtering.
+- `--arch` – target architecture (`RV32`, `RV64`, or `BOTH`).
+- `--output` – destination file (`-` for stdout).
+
+Run with `--verbose` to see which instructions cannot yet be mapped to a QEMU
+instruction format tag.