# 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