Source code for m2isar.metamodel.utils.scalar_staticness

# 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

"""Transformation functions to determine which vars in a function or instruction
behavior are to be considered static.
"""

import dataclasses
from functools import singledispatchmethod
from typing import Any, cast

from ...metamodel import arch, behav, attribute_info
from .ExprVisitor import ExprVisitor

# pylint: disable=unused-argument

[docs] class VarAccessVisitor(ExprVisitor): """Visitor that determines Variable staticness for behavior expression trees.""" @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: attribute_info.AccessContext): statements = [] for stmt in expr.statements: temp = self.generate(stmt, context) if isinstance(temp, list): statements.extend(temp) else: statements.append(temp) return expr
@generate.register def _(self, expr: behav.Block, context: attribute_info.AccessContext): explicit_attrs = getattr(expr, "explicit_attributes", set(expr.attributes)) explicit = attribute_info.BlockAttribute.ACCESS in explicit_attrs access = expr.attributes.get(attribute_info.BlockAttribute.ACCESS) if explicit else context.access_is_static block_context = dataclasses.replace(context, access_is_static=access) stmts = [self.generate(x, block_context) for x in expr.statements] valid = [s for s in stmts if s is not None] result = min([access] + valid) if not explicit: expr.attributes[attribute_info.BlockAttribute.ACCESS] = result return result @generate.register def _(self, expr: behav.BinaryOperation, context: attribute_info.AccessContext): left = self.generate(expr.left, context) right = self.generate(expr.right, context) return min(left, right) @generate.register def _(self, expr: behav.SliceOperation, context: attribute_info.AccessContext): expr_result = self.generate(expr.expr, context) left = self.generate(expr.left, context) right = self.generate(expr.right, context) return min(expr_result, left, right) @generate.register def _(self, expr: behav.ConcatOperation, context: attribute_info.AccessContext): left = self.generate(expr.left, context) right = self.generate(expr.right, context) return min(left, right) @generate.register def _(self, expr: behav.Literal, context: attribute_info.AccessContext): return attribute_info.AccessAttribute.READ @generate.register def _(self, expr: behav.Tensor, context: attribute_info.AccessContext): return attribute_info.AccessAttribute.READ @generate.register def _(self, expr: behav.VarDefinition, context: attribute_info.AccessContext): var = cast(Any, expr.var) var.attributes["static"] = attribute_info.AccessAttribute.RW return attribute_info.AccessAttribute.RW @generate.register def _(self, expr: behav.Break, context): return context.access_is_static @generate.register def _(self, expr: behav.Continue, context): return context.access_is_static @generate.register def _(self, expr: behav.Assignment, context: attribute_info.AccessContext): self.generate(expr.target, context) expr_static = attribute_info.AccessAttribute.NONE if context.access_is_static != attribute_info.AccessAttribute.NONE or isinstance(expr.target, behav.VarDefinition): expr_static = self.generate(expr.expr, context) if expr_static != attribute_info.AccessAttribute.NONE: expr_static = attribute_info.AccessAttribute.RW else: expr_static = attribute_info.AccessAttribute.NONE if isinstance(expr.target, behav.NamedReference) and isinstance(expr.target.reference, arch.Variable): target_ref = cast(Any, expr.target.reference) target_ref.attributes["static"] &= expr_static if isinstance(expr.target, behav.VarDefinition): target_var = cast(Any, expr.target.var) target_var.attributes["static"] &= expr_static @generate.register def _(self, expr: behav.Conditional, context: attribute_info.AccessContext): conds = [self.generate(x, context) for x in expr.conds] stmt_context = dataclasses.replace(context, access_is_static=min(conds)) stmts = [self.generate(x, stmt_context) for x in expr.stmts] return min(conds + [x for x in stmts if x is not None]) @generate.register def _(self, expr: behav.LoopBase, context: attribute_info.AccessContext): init = [self.generate(x, context) for x in expr.init] cond = self.generate(expr.cond, context) stmt_context = dataclasses.replace(context, access_is_static=cond) stmts = [self.generate(x, stmt_context) for x in expr.stmts] updates = [self.generate(x, stmt_context) for x in expr.updates] valid = [x for x in init + [cond] + stmts + updates if x is not None] loop_access = min(valid) if valid else cond # A for-loop iterator belongs to the same execution domain as its loop. # If a runtime-dependent branch (including break/continue) makes the body # dynamic, its initializer and update must not remain generator-static. if loop_access == attribute_info.AccessAttribute.NONE: for init_stmt in expr.init: if isinstance(init_stmt, behav.Assignment) and isinstance(init_stmt.target, behav.VarDefinition): init_stmt.target.var.attributes["static"] = loop_access return loop_access @generate.register def _(self, expr: behav.Ternary, context: attribute_info.AccessContext): cond = self.generate(expr.cond, context) then_expr = self.generate(expr.then_expr, context) else_expr = self.generate(expr.else_expr, context) return min(cond, then_expr, else_expr) @generate.register def _(self, expr: behav.Return, context: attribute_info.AccessContext): if expr.expr is not None: return self.generate(expr.expr, context) return attribute_info.AccessAttribute.RW @generate.register def _(self, expr: behav.UnaryOperation, context: attribute_info.AccessContext): right = self.generate(expr.right, context) if expr.op.value in ('++', '--'): target = expr.right while isinstance(target, (behav.Group, behav.SliceOperation)): target = target.expr reference = getattr(target, 'reference', None) if isinstance(reference, arch.Variable): static = attribute_info.AccessAttribute.RW if ( context.access_is_static != attribute_info.AccessAttribute.NONE and right != attribute_info.AccessAttribute.NONE) else attribute_info.AccessAttribute.NONE reference.attributes['static'] &= static return reference.attributes['static'] return right @generate.register def _(self, expr: behav.NamedReference, context: attribute_info.AccessContext): if isinstance(expr.reference, arch.Variable): return expr.reference.attributes.get("static") static_map = { arch.Memory: attribute_info.AccessAttribute.NONE, arch.RegisterBank: attribute_info.AccessAttribute.NONE, arch.Register: attribute_info.AccessAttribute.NONE, arch.Alias: attribute_info.AccessAttribute.NONE, arch.BitFieldDescr: attribute_info.AccessAttribute.READ, arch.Parameter: attribute_info.AccessAttribute.READ, arch.FnParam: attribute_info.AccessAttribute.READ } return static_map.get(type(expr.reference), attribute_info.AccessAttribute.NONE) @generate.register def _(self, expr: behav.IndexedReference, context: attribute_info.AccessContext): self.generate(expr.index, context) return attribute_info.AccessAttribute.NONE @generate.register def _(self, expr: behav.TypeConv, context: attribute_info.AccessContext): expr_result = self.generate(expr.expr, context) return expr_result @generate.register def _(self, expr: behav.Callable, context: attribute_info.AccessContext): args = [self.generate(arg, context) for arg in expr.args] is_static = bool(getattr(expr.ref_or_name, "attributes", {}).get("static", False)) args.append(attribute_info.AccessAttribute.READ if is_static else attribute_info.AccessAttribute.NONE) return min(args) @generate.register def _(self, expr: behav.ProcedureCall, context: attribute_info.AccessContext): args = [self.generate(arg, context) for arg in expr.args] is_static = bool(getattr(expr.ref_or_name, "attributes", {}).get("static", False)) args.append(attribute_info.AccessAttribute.READ if is_static else attribute_info.AccessAttribute.NONE) return min(args) @generate.register def _(self, expr: behav.Group, context: attribute_info.AccessContext): expr_result = self.generate(expr.expr, context) return expr_result