Source code for m2isar.backends.coredsl2.writer

# SPDX-License-Identifier: Apache-2.0
#
# This file is part of the M2-ISA-R project: https://github.com/tum-ei-eda/M2-ISA-R
#
# Copyright (C) 2022
# Chair of Electrical Design Automation
# Technical University of Munich

"""Clean M2-ISA-R/Seal5 metamodel to .core_desc file."""

import copy
import argparse
import logging
import pathlib


from ...metamodel import attribute_info, load_model
from ...metamodel.utils.scalar_staticness import VarAccessVisitor
from .utils import CoreDSL2Writer
from .visitor import CDSLWriterVisitor
from ...metrics import add_metrics_args, init_metrics, handle_metrics
from ...logging import add_logging_args, handle_logging_args
from ...iter_utils import process_sets, process_cores, process_sets_instructions, process_cores_instructions

[docs] logger = logging.getLogger("coredsl2_writer")
[docs] def assign_block_access(model_obj): """Materialize inferred staticness on every behavioral block.""" visitor = VarAccessVisitor() for container in list(model_obj.sets.values()) + list(model_obj.cores.values()): for fn_def in container.functions.values(): visitor.generate(fn_def.operation, attribute_info.AccessContext()) for always_block in container.always_blocks.values(): visitor.generate(always_block.operation, attribute_info.AccessContext()) for instr_def in [*container.instructions.values(), *container.unencoded_instructions.values()]: visitor.generate(instr_def.operation, attribute_info.AccessContext())
[docs] def write_cdsl_splitted(model_obj, out_path, ext: str = "core_desc", metrics=None, writer_cls=None, writer_kwargs=None): model_obj = copy.deepcopy(model_obj) # The instruction iterators operate on one collection; include pending # instructions so --splitted cannot silently omit auto encodings. for container in [*model_obj.sets.values(), *model_obj.cores.values()]: container.instructions = dict(container.instructions) container.instructions.update(container.unencoded_instructions) container.unencoded_instructions = {} assign_block_access(model_obj) assert out_path is not None out_path = pathlib.Path(out_path) assert out_path.is_dir(), "Expecting output directory when using --splitted" num_cores = len(model_obj.cores) num_sets = len(model_obj.sets) visitor = CDSLWriterVisitor() if writer_cls is None: writer_cls = CoreDSL2Writer if writer_kwargs is None: writer_kwargs = {} if num_sets > 0: def _helper(set_def, instr_def): writer = writer_cls(visitor, drop_first_op=False, **writer_kwargs) set_def_ = copy.deepcopy(set_def) set_def_.instructions = { key: instr_def_ for key, instr_def_ in set_def.instructions.items() if instr_def.name == instr_def_.name } writer.write_set(set_def_) content = writer.text set_name = set_def.name out_path_ = out_path / set_name / f"{instr_def.name}.{ext}" out_path_.parent.mkdir(exist_ok=True) with open(out_path_, "w", encoding="utf-8") as f: f.write(content) process_sets_instructions(model_obj, _helper, description="Writing CoreDSL2", metrics=metrics) if num_cores > 0: def _helper(core_def, instr_def): writer = writer_cls(visitor, drop_first_op=False, **writer_kwargs) core_def_ = copy.deepcopy(core_def) core_def_.instructions = { key: instr_def_ for key, instr_def_ in core_def.instructions.items() if instr_def.name == instr_def_.name } writer.write_core(core_def_) content = writer.text core_name = core_def.name out_path_ = out_path / core_name / f"{instr_def.name}.{ext}" out_path_.parent.mkdir(exist_ok=True) with open(out_path_, "w", encoding="utf-8") as f: f.write(content) process_cores_instructions(model_obj, _helper, description="Writing CoreDSL2", metrics=metrics) return metrics
[docs] def write_cdsl_default(model_obj, out_path, metrics=None, writer_cls=None, writer_kwargs=None): model_obj = copy.deepcopy(model_obj) assign_block_access(model_obj) num_cores = len(model_obj.cores) num_sets = len(model_obj.sets) visitor = CDSLWriterVisitor() if writer_cls is None: writer_cls = CoreDSL2Writer if writer_kwargs is None: writer_kwargs = {} writer = writer_cls(visitor, drop_first_op=False, **writer_kwargs) if num_sets > 0: def _helper(set_def): writer.write_set(set_def) process_sets(model_obj, _helper, description="Writing CoreDSL2", metrics=metrics) if num_cores > 0: def _helper(core_def): writer.write_core(core_def) process_cores(model_obj, _helper, description="Writing CoreDSL2", metrics=metrics) content = writer.text with open(out_path, "w", encoding="utf-8") as f: f.write(content) return metrics
[docs] def write_includes(writer, used_extensions, includes_prefix: str = "rv_base/", tum_includes_prefix: str = ""): if {"RV32I", "RV64I"}.intersection(used_extensions): writer.write(f'import "{includes_prefix}RVI.core_desc"', nl=True) if "RV32M" in used_extensions or "RV64M" in used_extensions: writer.write(f'import "{includes_prefix}RVM.core_desc"', nl=True) if "RV32IC" in used_extensions or "RV64IC" in used_extensions: writer.write(f'import "{includes_prefix}RVC.core_desc"', nl=True) if "RV32F" in used_extensions or "RV64F" in used_extensions: writer.write(f'import "{includes_prefix}RVF.core_desc"', nl=True) if "RV32D" in used_extensions or "RV64D" in used_extensions: writer.write(f'import "{includes_prefix}RVD.core_desc"', nl=True) # add tum extensions at the end if "tum_csr" in used_extensions: writer.write(f'import "{tum_includes_prefix}tum_mod.core_desc"', nl=True) writer.write(f'import "{tum_includes_prefix}tum_rva.core_desc"', nl=True) writer.write(f'import "{tum_includes_prefix}tum_rvm.core_desc"', nl=True) writer.write("\n")
[docs] def gen_cdsl_code(model_obj, with_includes=True, includes_prefix="rv_base/", tum_includes_prefix="", legacy=False): """Generate CoreDSL without modifying the caller's model or behavior.""" model_obj = copy.deepcopy(model_obj) writer = CoreDSL2Writer(CDSLWriterVisitor(), reduced=False, legacy=legacy) if with_includes: extensions = set() for core in model_obj.cores.values(): extensions.update(core.contributing_types) for instruction_set in model_obj.sets.values(): extensions.update(instruction_set.extension) write_includes(writer, extensions, includes_prefix, tum_includes_prefix) for instruction_set in model_obj.sets.values(): writer.write_set(instruction_set) for core in model_obj.cores.values(): writer.write_core(core) return writer.text
[docs] def main(argv=None): """Main app entrypoint.""" # read command line args parser = argparse.ArgumentParser() parser.add_argument("top_level", help="A .m2isarmodel or .seal5model file.") parser.add_argument("--output", "-o", type=str, default=None) parser.add_argument("--reduced", action="store_true", help="Generate pattern-gen compatible syntax") parser.add_argument("--operands", action="store_true", help="Include instruction operands in generated CoreDSL2.") parser.add_argument("--splitted", action="store_true", help="Split per set and instruction") parser.add_argument("--ext", type=str, default="core_desc", help="Default file extension (if using --splitted)") parser.add_argument("--legacy", action="store_true", help="Emit legacy assembly syntax") add_logging_args(parser) add_metrics_args(parser) args = parser.parse_args(argv) handle_logging_args(args) # resolve model paths top_level = pathlib.Path(args.top_level) if args.output is None: out_path = f"{top_level}.{args.ext}" else: out_path = pathlib.Path(args.output) # load models model_obj = load_model(top_level) allowed_attrs = None # all metrics = init_metrics() writer_kwargs = dict(reduced=args.reduced, allowed_attrs=allowed_attrs, legacy=args.legacy, emit_operands=args.operands) if args.splitted: metrics = write_cdsl_splitted( model_obj, out_path=out_path, ext=args.ext, metrics=metrics, writer_kwargs=writer_kwargs ) else: metrics = write_cdsl_default(model_obj, out_path=out_path, metrics=metrics, writer_kwargs=writer_kwargs) handle_metrics(metrics, dest=args.metrics, ignore_failing=args.ignore_failing)
if __name__ == "__main__": main()