fix: add backward compatibility for new instruction schema format (#1092)

This pull request enhances support for a new instruction schema in the
code generator by adding logic to interpret and convert the newer
`format` field into the legacy `encoding` format when loading
instructions. This ensures backward compatibility and smoother migration
to the new schema without breaking existing functionality.

**Support for new instruction schema:**

* Added a new function `build_match_from_format` in `generator.py` to
construct a match string from the `format` field, supporting 16-, 32-,
and 48-bit instructions. This function interprets opcode and variable
bit locations and values to generate the appropriate match string.
* Updated the instruction loading logic in `load_instructions` to detect
when only a `format` field (and not an `encoding` field) is present. If
found, it uses `build_match_from_format` to synthesize an `encoding`
entry, allowing the rest of the pipeline to function unchanged. If
conversion fails, the instruction is filtered out with an error log.

---------

Signed-off-by: Afonso Oliveira <[email protected]>
Co-authored-by: Afonso Oliveira <[email protected]>

Author: AliAlaa88

backends/generators/generator.py

@@ -17,6 +17,105 @@ def check_requirement(req, exts):
     return False
 
 
+def build_match_from_format(format_field):
+    """
+    Build a match string from the format field in the new schema.
+    """
+    if not format_field or "opcodes" not in format_field:
+        return None
+
+    # Determine instruction width by finding maximum bit position
+    valid_locations = []
+
+    opcodes = format_field["opcodes"]
+    # Check opcodes
+    for field_data in opcodes.values():
+        if isinstance(field_data, dict) and "location" in field_data:
+            if isinstance(field_data["location"], str):
+                try:
+                    location = field_data["location"]
+                    split_location = location.split("|")
+                    high = max(
+                        (
+                            int(location.split("-")[0])
+                            if "-" in location
+                            else int(location)
+                        )
+                        for location in split_location
+                    )
+                    valid_locations.append(high)
+                except (ValueError, IndexError):
+                    raise ValueError(
+                        f"Invalid location format: {field_data['location']}"
+                    )
+            elif isinstance(field_data["location"], int):
+                try:
+                    valid_locations.append(field_data["location"])
+                except (ValueError, IndexError):
+                    raise ValueError(
+                        f"Invalid location format: {field_data['location']}"
+                    )
+            else:
+                raise ValueError(f"Unknown location format: {field_data['location']}")
+
+    if "variables" in format_field:
+        variables = format_field["variables"]
+        # Check variables
+        for var_data in variables.values():
+            if isinstance(var_data, dict) and "location" in var_data:
+                if isinstance(var_data["location"], str):
+                    try:
+                        location = var_data["location"]
+                        if "-" in location:
+                            high = int(location.split("-")[0])
+                        else:
+                            high = int(location)
+                        valid_locations.append(high)
+                    except (ValueError, IndexError):
+                        raise ValueError(
+                            f"Invalid location format: {var_data['location']}"
+                        )
+                elif isinstance(var_data["location"], int):
+                    try:
+                        valid_locations.append(var_data["location"])
+                    except (ValueError, IndexError):
+                        raise ValueError(
+                            f"Invalid location format: {var_data['location']}"
+                        )
+                else:
+                    raise ValueError(f"Invalid location format: {var_data['location']}")
+
+    if not valid_locations:
+        raise ValueError("No valid bit locations found in format field")
+
+    max_bit = max(valid_locations)
+
+    # Set instruction width based on maximum bit position
+    width = max_bit + 1
+    match_bits = ["-"] * width
+
+    # Populate match string with opcode bits
+    for field_data in opcodes.values():
+        if isinstance(field_data, dict):
+            try:
+                location = field_data["location"]
+                if isinstance(location, str) and "-" in location:
+                    high, low = map(int, location.split("-"))
+                else:
+                    high = low = int(location)
+
+                if high < low or high >= width:
+                    logging.warning(f"Invalid bit range: {location}")
+                    continue  # Skip invalid bit ranges
+
+                binary_value = format(field_data["value"], f"0{high - low + 1}b")
+                match_bits[width - high - 1 : width - low] = binary_value
+            except (ValueError, IndexError):
+                raise ValueError(f"Error processing opcode field: {field_data}")
+
+    return "".join(match_bits)
+
+
 def parse_extension_requirements(extensions_spec):
     """
     Parse the extension requirements from the definedBy field.
@@ -177,11 +276,27 @@ def load_instructions(
 
             encoding = data.get("encoding", {})
             if not encoding:
-                logging.error(
-                    f"Missing 'encoding' field in instruction {name} in {path}"
-                )
-                encoding_filtered += 1
-                continue
+                # Check if this instruction uses the new schema with a 'format' field
+                format_field = data.get("format")
+                if not format_field:
+                    logging.error(
+                        f"Missing 'encoding' field in instruction {name} in {path}"
+                    )
+                    encoding_filtered += 1
+                    continue
+
+                # Try to build a match string from the format field
+                match_string = build_match_from_format(format_field)
+                if not match_string:
+                    logging.error(
+                        f"Could not build encoding from format field in instruction {name} in {path}"
+                    )
+                    encoding_filtered += 1
+                    continue
+
+                # Create a synthetic encoding compatible with existing logic
+                encoding = {"match": match_string, "variables": []}
+                logging.debug(f"Built encoding from format field for {name}")
 
             # Check if the instruction specifies a base architecture constraint
             base = data.get("base")