Integrate Brain branch with UDB in ext/ folder. Merge the output of the UDB with riscv-opcodes generation process to generate riscv-opcodes outputs.

AFOliveira · AFOliveira · commit fb3408dfceba · 2025-01-30T13:07:00.000Z
Signed-off-by: Afonso Oliveira &lt;Afonso.Oliveira@synopsys.com&gt;
diff --git a/ext/opcodes_maker/Makefile b/ext/opcodes_maker/Makefile
@@ -0,0 +1,61 @@
+# Directories
+YAML_DIR ?= ../../arch/inst
+OPCODES_DIR := ../riscv-opcodes
+OUTPUT_DIR := output
+
+# Python scripts
+YAML_TO_JSON := yaml_to_json.py
+GENERATOR := generator.py
+
+# Output files
+INSTR_DICT := $(OUTPUT_DIR)/instr_dict.json
+
+# Generated output files
+C_OUT := $(OUTPUT_DIR)/encoding.out.h
+CHISEL_OUT := $(OUTPUT_DIR)/inst.chisel
+SPINALHDL_OUT := $(OUTPUT_DIR)/inst.spinalhdl
+SVERILOG_OUT := $(OUTPUT_DIR)/inst.sverilog
+RUST_OUT := $(OUTPUT_DIR)/inst.rs
+GO_OUT := $(OUTPUT_DIR)/inst.go
+LATEX_OUT := $(OUTPUT_DIR)/instr-table.tex
+LATEX_PRIV_OUT := $(OUTPUT_DIR)/priv-instr-table.tex
+PROCESSED_DICT := $(OUTPUT_DIR)/processed_instr_dict.json
+
+# Check for required files
+REQUIRED_FILES := $(YAML_TO_JSON) $(GENERATOR)
+$(foreach file,$(REQUIRED_FILES),\
+    $(if $(wildcard $(file)),,$(error Required file $(file) not found)))
+
+# Default target
+all: generate
+
+# Create output directory
+$(OUTPUT_DIR):
+	mkdir -p $(OUTPUT_DIR)
+
+# Convert YAML to JSON
+$(INSTR_DICT): $(YAML_TO_JSON) | $(OUTPUT_DIR)
+	python3 $(YAML_TO_JSON) $(YAML_DIR) $(OUTPUT_DIR)
+
+# Generate all outputs
+generate: $(INSTR_DICT)
+	python3 $(GENERATOR) $(INSTR_DICT) -c -chisel -rust -go -latex
+	mv encoding.out.h inst.chisel inst.spinalhdl inst.sverilog inst.rs inst.go \
+	   instr-table.tex priv-instr-table.tex processed_instr_dict.json \
+	   $(OUTPUT_DIR)/ 2>/dev/null || true
+
+# Clean generated files
+clean:
+	rm -rf $(OUTPUT_DIR)
+
+# Help target
+help:
+	@echo "Available targets:"
+	@echo "  all (default) - Run complete pipeline: YAML -> JSON -> generate"
+	@echo "  generate     - Generate all output formats from JSON"
+	@echo "  clean        - Remove all generated files"
+	@echo ""
+	@echo "All output files will be placed in the '$(OUTPUT_DIR)' directory"
+	@echo "Use YAML_DIR=/path/to/yaml to specify custom YAML input directory"
+
+.PHONY: all generate clean help
diff --git a/ext/opcodes_maker/generator.py b/ext/opcodes_maker/generator.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import logging
+import pprint
+import os
+import sys
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Dict, List, Any
+
+# Add riscv-opcodes directory to Python path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+RISCV_OPCODES_DIR = os.path.join(SCRIPT_DIR, "..", "riscv-opcodes")
+sys.path.insert(0, RISCV_OPCODES_DIR)
+
+
+@contextmanager
+def working_directory(path):
+    """Context manager for changing the current working directory"""
+    prev_cwd = os.getcwd()
+    os.chdir(path)
+    try:
+        yield prev_cwd
+    finally:
+        os.chdir(prev_cwd)
+
+
+# Change to riscv-opcodes directory when importing to ensure relative paths work
+with working_directory(RISCV_OPCODES_DIR):
+    from c_utils import make_c
+    from chisel_utils import make_chisel
+    from constants import emitted_pseudo_ops
+    from go_utils import make_go
+    from latex_utils import make_latex_table, make_priv_latex_table
+    from rust_utils import make_rust
+    from sverilog_utils import make_sverilog
+
+LOG_FORMAT = "%(levelname)s:: %(message)s"
+LOG_LEVEL = logging.INFO
+
+pretty_printer = pprint.PrettyPrinter(indent=2)
+logging.basicConfig(level=LOG_LEVEL, format=LOG_FORMAT)
+
+
+def load_instruction_dict(json_path: str) -> Dict[str, Any]:
+    """
+    Load instruction dictionary from a JSON file.
+    """
+    try:
+        with open(json_path, encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        logging.error(f"Input JSON file not found: {json_path}")
+        raise
+    except json.JSONDecodeError:
+        logging.error(f"Invalid JSON format in file: {json_path}")
+        raise
+
+
+def move_file(src: str, dest_dir: str):
+    """
+    Move a file to the destination directory if it exists.
+    """
+    if os.path.exists(src):
+        dest = os.path.join(dest_dir, os.path.basename(src))
+        shutil.move(src, dest)
+
+
+def generate_outputs(
+    instr_dict: Dict[str, Any],
+    include_pseudo: bool,
+    c: bool,
+    chisel: bool,
+    spinalhdl: bool,
+    sverilog: bool,
+    rust: bool,
+    go: bool,
+    latex: bool,
+):
+    """
+    Generate output files based on the instruction dictionary.
+    """
+    # Sort the dictionary for consistent output
+    instr_dict = dict(sorted(instr_dict.items()))
+
+    # Save the processed dictionary in current directory
+    with open("processed_instr_dict.json", "w", encoding="utf-8") as outfile:
+        json.dump(instr_dict, outfile, indent=2)
+
+    # Generate files in riscv-opcodes directory and move them to current directory
+    with working_directory(RISCV_OPCODES_DIR) as orig_dir:
+        if c:
+            # For C output, filter pseudo-ops if needed
+            if not include_pseudo:
+                c_dict = {
+                    k: v for k, v in instr_dict.items() if k not in emitted_pseudo_ops
+                }
+            else:
+                c_dict = instr_dict
+            make_c(c_dict)
+            move_file("encoding.out.h", orig_dir)
+            logging.info("encoding.out.h generated successfully")
+
+        if chisel:
+            make_chisel(instr_dict)
+            move_file("inst.chisel", orig_dir)
+            logging.info("inst.chisel generated successfully")
+
+        if spinalhdl:
+            make_chisel(instr_dict, True)
+            move_file("inst.spinalhdl", orig_dir)
+            logging.info("inst.spinalhdl generated successfully")
+
+        if sverilog:
+            make_sverilog(instr_dict)
+            move_file("inst.sverilog", orig_dir)
+            logging.info("inst.sverilog generated successfully")
+
+        if rust:
+            make_rust(instr_dict)
+            move_file("inst.rs", orig_dir)
+            logging.info("inst.rs generated successfully")
+
+        if go:
+            make_go(instr_dict)
+            move_file("inst.go", orig_dir)
+            logging.info("inst.go generated successfully")
+
+        if latex:
+            make_latex_table()
+            make_priv_latex_table()
+            move_file("instr-table.tex", orig_dir)
+            move_file("priv-instr-table.tex", orig_dir)
+            logging.info("LaTeX files generated successfully")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate RISC-V constants from JSON input"
+    )
+    parser.add_argument(
+        "input_json", help="Path to JSON file containing instruction definitions"
+    )
+    parser.add_argument(
+        "-pseudo", action="store_true", help="Include pseudo-instructions"
+    )
+    parser.add_argument("-c", action="store_true", help="Generate output for C")
+    parser.add_argument(
+        "-chisel", action="store_true", help="Generate output for Chisel"
+    )
+    parser.add_argument(
+        "-spinalhdl", action="store_true", help="Generate output for SpinalHDL"
+    )
+    parser.add_argument(
+        "-sverilog", action="store_true", help="Generate output for SystemVerilog"
+    )
+    parser.add_argument("-rust", action="store_true", help="Generate output for Rust")
+    parser.add_argument("-go", action="store_true", help="Generate output for Go")
+    parser.add_argument("-latex", action="store_true", help="Generate output for Latex")
+
+    args = parser.parse_args()
+
+    # Load instruction dictionary from JSON
+    instr_dict = load_instruction_dict(args.input_json)
+
+    print(f"Loaded instruction dictionary from: {args.input_json}")
+
+    # Generate outputs based on the loaded dictionary
+    generate_outputs(
+        instr_dict,
+        args.pseudo,
+        args.c,
+        args.chisel,
+        args.spinalhdl,
+        args.sverilog,
+        args.rust,
+        args.go,
+        args.latex,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ext/opcodes_maker/sorter.py b/ext/opcodes_maker/sorter.py
@@ -0,0 +1,30 @@
+import json
+
+
+def sort_instr_json(dir_name, outname):
+    with open(dir_name) as file:
+        data = json.load(file)
+
+    sorted_data = {}
+    for key in sorted(data):
+        entry = data[key]
+        if "variable_fields" in entry:
+            entry["variable_fields"] = sorted(entry["variable_fields"])
+        if "extension" in entry:
+            entry["extension"] = sorted(entry["extension"])
+
+        # Add the processed entry to the sorted data
+        sorted_data[key] = entry
+
+    with open(outname, "w") as file:
+        json.dump(sorted_data, file, indent=4)
+
+    print(json.dumps(sorted_data, indent=4))
+
+
+def main():
+    sort_instr_json("instr_dict.json", "udb_sorted_data.json")
+    sort_instr_json("instr_dict.json", "opcodes_sorted_data.json")
+
+
+main()
diff --git a/ext/opcodes_maker/yaml_to_json.py b/ext/opcodes_maker/yaml_to_json.py
