Source code for m2isar.metamodel.utils.expr_simplifier

# 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

"""A transformation module for simplifying M2-ISA-R behavior expressions. The following
simplifications are done:

* Resolvable :class:`m2isar.metamodel.arch.Parameter` s are replaced by
  `m2isar.metamodel.arch.Literal` s representing their value
* Conditions and loops with fully resolvable conditions are either discarded entirely
  or transformed into code blocks without any conditions
* Ternaries with fully resolvable conditions are transformed into only the matching part
* Type conversions remain explicit to preserve their declared types and
  constant-expression provenance for validation.
"""

from ...metamodel import arch, behav, type_info
from .ExprVisitor import ExprVisitor
from functools import singledispatchmethod

# pylint: disable=unused-argument

[docs] class ExprSimplifierVisitor(ExprVisitor): """Visitor that simplifies behavior expression trees."""
[docs] def _simplify_condition(self, expr): """Drop logical identities when only an expression's truth value matters.""" if isinstance(expr, behav.Group): return self._simplify_condition(expr.expr) if not isinstance(expr, behav.BinaryOperation) or expr.op.value not in ('&&', '||'): return expr left = self._simplify_condition(expr.left) right = self._simplify_condition(expr.right) expr.left = left expr.right = right is_and = expr.op.value == '&&' if isinstance(left, behav.Literal): left_truth = bool(left.value) if (is_and and not left_truth) or (not is_and and left_truth): return behav.Literal(int(left_truth), type_info.PrimitiveType(type_info.TypeKind.UINT, 1), line_info=expr.line_info) # The left literal is the identity value; the right operand is still # evaluated in the same order and only its truth value is observed. return right if isinstance(right, behav.Literal): right_truth = bool(right.value) if (is_and and right_truth) or (not is_and and not right_truth): # The left operand must still be evaluated, but the logical result # is used only as a condition, so its truth value is sufficient. return left return expr
@singledispatchmethod
[docs] def generate(self, expr : behav.BaseNode, context=None): raise NotImplementedError(f"No visit method implemented for type {type(expr).__name__} in {type(expr).__name__}")
@generate.register
[docs] def _(self, expr: behav.Operation, context): statements = [] for stmt in expr.statements: try: temp = self.generate(stmt, context) if isinstance(temp, list): statements.extend(temp) else: statements.append(temp) except (NotImplementedError, ValueError): print(f"cant simplify {stmt}") expr.statements = statements return expr
@generate.register def _(self, expr: behav.Block, context): expr.statements = [self.generate(x, context) for x in expr.statements] return expr @generate.register def _(self, expr: behav.BinaryOperation, context): expr.left = self.generate(expr.left, context) expr.right = self.generate(expr.right, context) if isinstance(expr.left, behav.Literal) and isinstance(expr.right, (behav.NamedReference, behav.IndexedReference)): if expr.left.ty.size < arch.get_const_or_val(expr.right.reference.ty.size): expr.left.ty.size = arch.get_const_or_val(expr.right.reference.ty.size) if isinstance(expr.right, behav.Literal) and isinstance(expr.left, (behav.NamedReference, behav.IndexedReference)): if isinstance(expr.left.ty, type_info.ArrayType): if expr.right.ty.size < arch.get_const_or_val(expr.left.reference.ty.element_type.size): expr.right.ty.size = arch.get_const_or_val(expr.left.reference.ty.element_type.size) else: if expr.right.ty.size < arch.get_const_or_val(expr.left.ty.size): expr.right.ty.size = arch.get_const_or_val(expr.left.ty.size) if expr.op.value in ('&&', '||'): boolean_type = type_info.PrimitiveType(type_info.TypeKind.UINT, 1) if isinstance(expr.left, behav.Literal): left = bool(expr.left.value) if (expr.op.value == '&&' and not left) or (expr.op.value == '||' and left): return behav.Literal(int(left), boolean_type) if isinstance(expr.right, behav.Literal): return behav.Literal(int(bool(expr.right.value)), boolean_type) # Keep Boolean normalization and evaluation of a nonconstant left # operand, including when the right constant determines the result. return expr return expr @generate.register def _(self, expr: behav.SliceOperation, context): expr.expr = self.generate(expr.expr, context) expr.left = self.generate(expr.left, context) expr.right = self.generate(expr.right, context) return expr @generate.register def _(self, expr: behav.ConcatOperation, context): expr.left = self.generate(expr.left, context) expr.right = self.generate(expr.right, context) return expr @generate.register def _(self, expr: behav.Literal, context): return expr @generate.register def _(self, expr: behav.Tensor, context): return expr @generate.register def _(self, expr: behav.VarDefinition, context): return expr @generate.register def _(self, expr: behav.Break, context): return expr @generate.register def _(self, expr: behav.Continue, context): return expr @generate.register def _(self, expr: behav.Assignment, context): expr.target = self.generate(expr.target, context) expr.expr = self.generate(expr.expr, context) if isinstance(expr.expr, behav.Literal) and isinstance(expr.target, (behav.NamedReference, behav.IndexedReference)): if expr.expr.ty.size < arch.get_const_or_val(expr.target.ty.size): expr.expr.ty.size = arch.get_const_or_val(expr.target.ty.size) return expr @generate.register def _(self, expr: behav.Conditional, context): expr.conds = [self._simplify_condition(self.generate(x, context)) for x in expr.conds] expr.stmts = [self.generate(x, context) for x in expr.stmts] eval_false = True conds = [] stmts = [] for cond, stmt in zip(expr.conds, expr.stmts): if isinstance(cond, behav.Literal): if cond.value: return stmt else: conds.append(cond) stmts.append(stmt) eval_false = False if len(expr.conds) < len(expr.stmts): if eval_false and isinstance(expr.conds[-1], behav.Literal): if not cond.value: # pylint: disable=undefined-loop-variable return expr.stmts[-1] stmts.append(expr.stmts[-1]) expr.conds = conds expr.stmts = stmts return expr @generate.register def _(self, expr: behav.LoopBase, context): expr.init = [self.generate(x, context) for x in expr.init] expr.cond = self._simplify_condition(self.generate(expr.cond, context)) expr.stmts = [self.generate(x, context) for x in expr.stmts] expr.updates = [self.generate(x, context) for x in expr.updates] return expr @generate.register def _(self, expr: behav.Ternary, context): expr.cond = self._simplify_condition(self.generate(expr.cond, context)) expr.then_expr = self.generate(expr.then_expr, context) expr.else_expr = self.generate(expr.else_expr, context) if isinstance(expr.cond, behav.Literal): if expr.cond.value: return expr.then_expr return expr.else_expr return expr @generate.register def _(self, expr: behav.Return, context): if expr.expr is not None: expr.expr = self.generate(expr.expr, context) return expr @generate.register def _(self, expr: behav.UnaryOperation, context): if expr.op.value in ('++', '--'): return expr # Preserve target identity and side effects, including invalid constants. expr.right = self.generate(expr.right, context) return expr @generate.register def _(self, expr: behav.NamedReference, context): if isinstance(expr.reference, arch.Parameter): if expr.reference.signed: kind = type_info.TypeKind.INT else: kind = type_info.TypeKind.UINT return behav.Literal(expr.reference.value, type_info.PrimitiveType(kind, arch.get_const_or_val(expr.reference.size))) return expr @generate.register def _(self, expr: behav.IndexedReference, context): expr.index = self.generate(expr.index, context) return expr @generate.register def _(self, expr: behav.TypeConv, context): expr.expr = self.generate(expr.expr, context) return expr @generate.register def _(self, expr: behav.Callable, context): expr.args = [self.generate(stmt, context) for stmt in expr.args] return expr @generate.register def _(self, expr: behav.ProcedureCall, context): expr.args = [self.generate(stmt, context) for stmt in expr.args] return expr @generate.register def _(self, expr: behav.Group, context): expr.expr = self.generate(expr.expr, context) if isinstance(expr.expr, behav.Literal): return expr.expr return expr