Source code for m2isar.frontends.coredsl2.expr_interpreter

# 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

"""Very crude expression evaluation functions for use during model generation."""

from ... import M2ValueError
from ...diagnostics import M2ValidationError
from .constant_expressions import BINARY, cast_integer
from ...metamodel import arch, behav, type_info
from ...metamodel.utils.ExprVisitor import ExprVisitor
from functools import singledispatchmethod


[docs] class ExprInterpreterVisitor(ExprVisitor): """Visitor for evaluating parse-time constant expressions.""" @singledispatchmethod
[docs] def generate(self, expr: behav.BaseNode, context=None): raise NotImplementedError(f"No visit method implemented for type {type(expr).__name__} in {type(self).__name__}")
@generate.register
[docs] def _(self, expr: behav.Group, context): return self.generate(expr.expr, context)
@generate.register def _(self, expr: behav.Literal, context): return int(expr.value) @generate.register def _(self, expr: behav.TypeConv, context): value = self.generate(expr.expr, context) width = arch.get_const_or_val(expr.size) if width is None: from ...transforms.infer_types.visitor import InferTypesMutator from ...warnings import WarningsManager InferTypesMutator().generate(expr.expr, WarningsManager(None)) width = arch.get_const_or_val(expr.expr.ty.size) if not isinstance(width, int) or width <= 0: raise M2ValueError("cast width must be a positive constant") try: return cast_integer(value, width, expr.data_type == type_info.TypeKind.INT) except ValueError as exc: raise M2ValueError(str(exc)) from exc @generate.register def _(self, expr: behav.NamedReference, context): if isinstance(expr.reference, arch.Parameter) and expr.reference.value is not None: return expr.reference.value raise M2ValueError("non-interpretable value encountered") @generate.register def _(self, expr: behav.IndexedReference, context): if context: raise M2ValueError("Array initializer must contain constant expressions") idx = self.generate(expr.index, context) return expr.reference._initval[idx] @generate.register def _(self, expr: behav.BinaryOperation, context): left = self.generate(expr.left, context) op = expr.op.value if context and op == '&&' and not left: return 0 if context and op == '||' and left: return 1 right = self.generate(expr.right, context) if op in BINARY: value = int(BINARY[op](left, right)) if context and op in ('&', '|', '^'): from ...transforms.infer_types.visitor import InferTypesMutator from ...warnings import WarningsManager InferTypesMutator().generate(expr, WarningsManager(None)) width = arch.get_const_or_val(expr.ty.size) if not isinstance(width, int) or width <= 0: raise M2ValueError("result width must be a positive constant") try: return cast_integer(value, width, expr.ty.kind == type_info.TypeKind.INT) except ValueError as exc: raise M2ValueError(str(exc)) from exc return value if context and op in ('&&', '||'): return int(bool(right)) if op == '/' or context and op == '%': if right == 0: raise M2ValidationError("Division by zero", 'DivisionByZero', expr.line_info) value = abs(left) // abs(right) quotient = -value if (left < 0) != (right < 0) else value return left - quotient * right if op == '%' else quotient if op in ('<<', '>>'): shift = right if op == '<<' else -right if context: from ...transforms.infer_types.visitor import InferTypesMutator from ...warnings import WarningsManager InferTypesMutator().generate(expr.left, WarningsManager(None)) width = arch.get_const_or_val(expr.left.ty.size) if not isinstance(width, int) or width <= 0: raise M2ValueError("operand width must be a positive constant") if shift >= width: return 0 if shift > 100000: raise M2ValueError("constant shift is too large") value = left << shift if shift >= 0 else left >> -shift if context: try: return cast_integer(value, width, expr.left.ty.kind == type_info.TypeKind.INT) except ValueError as exc: raise M2ValueError(str(exc)) from exc return value raise M2ValidationError(f"Infix expression {op} is currently unsupported in constant expressions", 'UnsupportedLanguageFeature', expr.line_info) @generate.register def _(self, expr: behav.Ternary, context): if not context: raise M2ValidationError("Ternary is not allowed in constant expression", 'InvalidConstantExpressionNode', expr.line_info) branch = expr.then_expr if self.generate(expr.cond, context) else expr.else_expr return self.generate(branch, context) @generate.register def _(self, expr: behav.UnaryOperation, context): right = self.generate(expr.right, context) if expr.op.value == '-': return -right if context and expr.op.value in ('+', '~', '!'): if expr.op.value == '+': return right if expr.op.value == '!': return int(not right) from ...transforms.infer_types.visitor import InferTypesMutator from ...warnings import WarningsManager InferTypesMutator().generate(expr.right, WarningsManager(None)) width = arch.get_const_or_val(expr.right.ty.size) if not isinstance(width, int) or width <= 0: raise M2ValueError("operand width must be a positive constant") try: return cast_integer(~right, width, expr.right.ty.kind == type_info.TypeKind.INT) except ValueError as exc: raise M2ValueError(str(exc)) from exc raise M2ValidationError(f"prefix operator {expr.op.value} is not allowed in constant expression", 'InvalidConstantExpressionNode', expr.line_info)