# 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
import logging
from copy import copy
from functools import singledispatchmethod
from m2isar.metamodel import arch, behav, type_info
from ...diagnostics import M2ValidationError, M2WarningError
from ...metamodel.utils.ExprVisitor import ExprVisitor
from .constants import constant_value, holds_value, INDETERMINATE, range_size
[docs]
logger = logging.getLogger("validate_behav")
# pylint: disable=unused-argument
[docs]
class ValidateBehavVisitor(ExprVisitor):
"""Visitor to validate a metamodel."""
@staticmethod
[docs]
def _validate_assignment_target(target, line_info):
# Index accesses recurse to their base. Parentheses are not lvalues
# in MINRES 2.0.21, even when they contain a writable reference.
while isinstance(target, behav.SliceOperation):
target = target.expr
reference = getattr(target, 'reference', None)
invalid = not isinstance(target, (behav.NamedReference, behav.IndexedReference))
invalid = invalid or bool(getattr(target, 'grouped_base', False))
invalid = invalid or isinstance(reference, (arch.Parameter, arch.BitFieldDescr, arch.Function))
invalid = invalid or bool(getattr(reference, 'attributes', {}).get('const'))
invalid = invalid or bool(getattr(reference, 'coredsl_const', False))
if invalid:
raise M2ValidationError('Invalid assignment target', 'InvalidAssignmentTarget', line_info)
[docs]
def _validate_statements(self, operation, context):
locations = getattr(operation, '_stray_control_flow_locations', None)
if locations is None:
locations = [('break', location) for location in
(getattr(operation, '_stray_break_locations', None) or [])]
locations.extend(('continue', location) for location in
(getattr(operation, '_stray_continue_locations', None) or []))
errors = [M2ValidationError(f'Unexpected {kind} statement',
'StrayControlFlowStatement', location)
for kind, location in locations]
previous_breaks = getattr(self, '_preserved_breaks_active', False)
previous_continues = getattr(self, '_preserved_continues_active', False)
self._preserved_breaks_active = previous_breaks or any(kind == 'break' for kind, _ in locations)
self._preserved_continues_active = previous_continues or any(kind == 'continue' for kind, _ in locations)
try:
for statement in operation.statements:
try:
self.generate(statement, context)
except M2ValidationError as error:
errors.append(error)
finally:
self._preserved_breaks_active = previous_breaks
self._preserved_continues_active = previous_continues
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
[docs]
def _validate_children(self, children, context):
errors = []
for child in children:
try:
self.generate(child, context)
except M2ValidationError as error:
errors.append(error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
[docs]
_range_size = staticmethod(range_size)
@staticmethod
[docs]
def _range_overflows(target_type, bounds):
count = ValidateBehavVisitor._range_size(*bounds)
if count is None:
return False
if isinstance(target_type, type_info.PrimitiveType) and target_type.kind.is_int:
element_bits = 1
elif isinstance(target_type, type_info.ArrayType):
element = target_type.element_type
element_bits = 1
while isinstance(element, type_info.ArrayType):
length = arch.get_const_or_val(element.length)
if not isinstance(length, int) or length < 0:
return False
element_bits *= length
element = element.element_type
if not isinstance(element, type_info.PrimitiveType) or not element.kind.is_int:
return False
width = arch.get_const_or_val(element.size)
if not isinstance(width, int) or width <= 0:
return False
element_bits *= width
else:
return False
return element_bits * count > 2147483647
[docs]
def _validate_access(self, children, indices, context, target_type=None, target_line_info=None, range_bounds=None):
errors = []
try:
self._validate_children(children, context)
except M2ValidationError as error:
errors.append(error)
if isinstance(target_type, type_info.PrimitiveType) and target_type.kind.is_void:
errors.append(M2ValidationError('Cannot index into void', 'NonIndexableExpression',
target_line_info))
first_error = bool(indices) and self._has_invalid_type(indices[0])
first_type = getattr(indices[0], 'ty', None) if indices else None
while isinstance(first_type, type_info.ArrayType):
length = arch.get_const_or_val(first_type.length)
if not isinstance(length, int) or length < 0:
first_error = True
break
first_type = first_type.element_type
for position, index in enumerate(indices):
ty = getattr(index, 'ty', None)
if position:
# The release deliberately guards the end index with the start type.
invalid_index = not first_error and (
self._has_invalid_type(index) or isinstance(ty, type_info.ArrayType)
or isinstance(ty, type_info.PrimitiveType) and ty.kind.is_void)
else:
invalid_index = not self._has_invalid_type(index) and self._known_type_name(ty) is not None and (
isinstance(ty, type_info.ArrayType)
or isinstance(ty, type_info.PrimitiveType) and ty.kind.is_void)
if invalid_index:
errors.append(M2ValidationError('Index must have an integer type',
'InvalidIndexType', index.line_info))
if range_bounds is not None:
def report_constant_error(node, error):
errors.append(M2ValidationError('Division by zero', 'DivisionByZero',
node.line_info or target_line_info))
count = range_size(*range_bounds, on_error=report_constant_error)
if count is None:
if not getattr(context, 'partial', False):
errors.append(M2ValidationError('Invalid range pattern', 'InvalidRangePattern', target_line_info))
elif self._range_overflows(target_type, range_bounds):
errors.append(M2ValidationError(
'The combined size of the selected elements must not exceed Integer.MAX_VALUE',
'InvalidIntegerTypeSize', target_line_info))
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@staticmethod
[docs]
def is_return_terminated(statement):
if isinstance(statement, behav.Return):
return True
if isinstance(statement, behav.Operation):
return bool(statement.statements) and ValidateBehavVisitor.is_return_terminated(statement.statements[-1])
if isinstance(statement, behav.Conditional):
return (bool(statement.conds) and len(statement.stmts) == len(statement.conds) + 1
and all(ValidateBehavVisitor.is_return_terminated(branch) for branch in statement.stmts))
return False
@staticmethod
[docs]
def _declared_size(value, line_info):
try:
return value if isinstance(value, int) else constant_value(value)
except ZeroDivisionError:
raise M2ValidationError('Division by zero', 'DivisionByZero', line_info)
@staticmethod
[docs]
def _validate_declared_sizes(ty, line_info):
while isinstance(ty, type_info.ArrayType):
count = ValidateBehavVisitor._declared_size(ty.length, line_info)
if isinstance(count, int) and count < 0:
raise M2ValidationError('Negative array size is invalid', 'InvalidArraySize', line_info)
ty = ty.element_type
if isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int:
width = ValidateBehavVisitor._declared_size(ty.size, line_info)
if isinstance(width, int):
if width <= 0:
raise M2ValidationError('Integer type size must be greater than 0',
'InvalidIntegerTypeSize', line_info)
if width > 2147483647:
raise M2ValidationError('Integer type size must not exceed Integer.MAX_VALUE',
'InvalidIntegerTypeSize', line_info)
@staticmethod
[docs]
def _known_type_name(ty):
if isinstance(ty, type_info.PrimitiveType):
if ty.kind == type_info.TypeKind.VOID:
return 'void'
if ty.kind.is_int:
width = arch.get_const_or_val(ty.size)
if isinstance(width, int) and width > 0:
return f'{"signed" if ty.kind == type_info.TypeKind.INT else "unsigned"}<{width}>'
if isinstance(ty, type_info.ArrayType):
element = ValidateBehavVisitor._known_type_name(ty.element_type)
count = arch.get_const_or_val(ty.length)
if element is not None and isinstance(count, int) and count >= 0:
return f'{element}[{count}]'
return None
@staticmethod
[docs]
def _incompatible_option_names(expr):
then_type, else_type = expr.then_expr.ty, expr.else_expr.ty
then_name = ValidateBehavVisitor._known_type_name(then_type)
else_name = ValidateBehavVisitor._known_type_name(else_type)
integers = all(isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int
for ty in (then_type, else_type))
if (then_name is not None and else_name is not None
and then_name != else_name and not integers):
return then_name, else_name
return None
@staticmethod
[docs]
def _has_invalid_type(expr):
"""Recognize invalid results without mutating execution types."""
invalid = ValidateBehavVisitor._has_invalid_type
if isinstance(expr, behav.SliceOperation):
ty = getattr(expr.expr, 'ty', None)
return (isinstance(ty, type_info.PrimitiveType) and ty.kind.is_void
or invalid(expr.expr)
or expr.left is not expr.right
and (ValidateBehavVisitor._range_size(expr.left, expr.right) is None
or ValidateBehavVisitor._range_overflows(ty, (expr.left, expr.right))))
if isinstance(expr, behav.IndexedReference):
ty = getattr(expr.reference, 'ty', None)
return (isinstance(ty, type_info.PrimitiveType) and ty.kind.is_void
or expr.right is not None
and (ValidateBehavVisitor._range_size(expr.index, expr.right) is None
or ValidateBehavVisitor._range_overflows(ty, (expr.index, expr.right))))
if isinstance(expr, behav.Group):
return invalid(expr.expr)
if isinstance(expr, (behav.BinaryOperation, behav.ConcatOperation)):
return invalid(expr.left) or invalid(expr.right)
if isinstance(expr, behav.Ternary):
return (invalid(expr.then_expr) or invalid(expr.else_expr)
or ValidateBehavVisitor._incompatible_option_names(expr) is not None)
if isinstance(expr, behav.TypeConv) and expr.size is None:
ty = expr.expr.ty
noninteger = (ValidateBehavVisitor._known_type_name(ty) is not None
and not (isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int))
return invalid(expr.expr) or noninteger
if isinstance(expr, behav.UnaryOperation) and expr.op.value in ('+', '~', '++', '--'):
return invalid(expr.right)
return False
[docs]
def _validate_condition(self, condition):
if self._has_invalid_type(condition):
return
ty = condition.ty
name = self._known_type_name(ty)
if name is not None and (isinstance(ty, type_info.ArrayType)
or isinstance(ty, type_info.PrimitiveType) and ty.kind.is_void):
raise M2ValidationError('The condition must be a scalar type, but was ' + name,
'NonScalarCondition', condition.line_info)
[docs]
def _implicitly_convertible(self, source_type, target_type):
source, target = self._known_type_name(source_type), self._known_type_name(target_type)
if source is None or target is None:
return None
if (isinstance(source_type, type_info.PrimitiveType) and source_type.kind.is_int
and isinstance(target_type, type_info.PrimitiveType) and target_type.kind.is_int):
source_width = arch.get_const_or_val(source_type.size)
target_width = arch.get_const_or_val(target_type.size)
return (source_width <= target_width
and not (source_type.kind == type_info.TypeKind.INT and target_type.kind == type_info.TypeKind.UINT)
and not (source_type.kind == type_info.TypeKind.UINT and target_type.kind == type_info.TypeKind.INT
and source_width == target_width))
return source == target
[docs]
def _validate_scalar_conversion(self, target_type, value_node, context, line_info,
issue_code='InvalidAssignmentType'):
if self._has_invalid_type(value_node):
return
target, source = self._known_type_name(target_type), self._known_type_name(value_node.ty)
if target is not None and source is not None:
compatible = self._implicitly_convertible(value_node.ty, target_type)
target_integer = isinstance(target_type, type_info.PrimitiveType) and target_type.kind.is_int
if not compatible:
try:
value = constant_value(value_node, allow_casts=getattr(context, 'architectural_initializer', False))
except ZeroDivisionError:
raise M2ValidationError('Division by zero', 'DivisionByZero', value_node.line_info)
allowed = (target_integer and value is not None and value is not INDETERMINATE
and holds_value(target_type, value))
if allowed or value is INDETERMINATE and getattr(context, 'partial', False):
logger.info('Assignment is allowed despite type incompatibility, because the right hand side is a constant '
'[com.minres.coredsl.ValidConstantAssignment]')
else:
raise M2ValidationError(f'Cannot implicitly convert {source} to {target}',
issue_code, line_info)
@singledispatchmethod
[docs]
def generate(self, expr: behav.BaseNode, context):
raise NotImplementedError(f"No visit method implemented for type {type(expr).__name__} in {type(self).__name__}")
@generate.register
[docs]
def _(self, expr: behav.Operation, context):
self._validate_statements(expr, context)
@generate.register
def _(self, expr: behav.Block, context):
self._validate_statements(expr, context)
@generate.register
def _(self, expr: behav.BinaryOperation, context):
errors = []
for operand in (expr.left, expr.right):
try:
self.generate(operand, context)
except M2ValidationError as error:
errors.append(error)
op = expr.op
if not self._has_invalid_type(expr):
if expr.left.ty is None:
context.emit_warning("Missing infered LHS binop type.", "incomplete-type-info", logger=logger, line_info=expr.left.line_info)
if expr.right.ty is None:
context.emit_warning("Missing infered RHS binop type.", "incomplete-type-info", logger=logger, line_info=expr.right.line_info)
assert expr.left.ty is not None
assert expr.right.ty is not None
if op.value in ["|", "&", "^"] and expr.left.ty.size != expr.right.ty.size:
context.emit_warning("Bitwise operations with differently size operands are discouraged.", "bit-op-missmatch", logger=logger, line_info=expr.line_info)
if op.value in ["<<", ">>", ">>>"] and expr.right.ty.kind == type_info.TypeKind.INT:
context.emit_warning("Shift by signed amount", "shift-signed", logger=logger, line_info=expr.line_info)
if op.value in ["<", "<=", ">", ">=", "==", "!="] and expr.left.ty.kind != expr.right.ty.kind:
assert(expr.left.ty.kind.is_int and expr.right.ty.kind.is_int)
if isinstance(expr.left, behav.Literal) and expr.left.value == 0:
pass
elif isinstance(expr.right, behav.Literal) and expr.right.value == 0:
pass
else:
context.emit_warning(f"Signed vs. unsigned comparison", "sign-compare", logger=logger, line_info=expr.line_info)
# TODO: also check possible range of non-literal rhs?
if op.value in ("<<", ">>") and isinstance(expr.right, behav.Literal) and arch.get_const_or_val(expr.left.ty.size) <= expr.right.value:
context.emit_warning(f"Shift count overflow for {op.value} operation ({expr.left.ty.size} vs. {expr.right.value})", "shift-overflow", logger=logger, line_info=expr.line_info)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.SliceOperation, context):
children = [expr.expr, expr.left]
if expr.right is not expr.left:
children.append(expr.right)
errors = []
try:
self._validate_access(children, children[1:], context,
getattr(expr.expr, "ty", None), expr.expr.line_info,
(expr.left, expr.right) if expr.left is not expr.right else None)
except M2ValidationError as error:
errors.append(error)
bounds_error = None if errors else self._slice_bounds_error(expr)
if bounds_error is not None:
errors.append(bounds_error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@staticmethod
[docs]
def _slice_bounds_error(expr):
"""Report statically known slice bounds beyond the operand width."""
ty = getattr(expr.expr, 'ty', None)
if not (isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int):
return None
width = arch.get_const_or_val(ty.size)
if not isinstance(width, int) or width <= 0:
return None
try:
left, right = constant_value(expr.left), constant_value(expr.right)
except ZeroDivisionError:
return None
if not all(isinstance(v, int) and not isinstance(v, bool) for v in (left, right)):
return None
if max(left, right) < width:
return None
text = f'[{left}]' if expr.left is expr.right else f'[{left}:{right}]'
return M2ValidationError(
f'Bit slice {text} exceeds operand width of {width} bits (valid range: [{width - 1}:0])',
'OutOfBoundsBitSlice', expr.line_info)
@generate.register
def _(self, expr: behav.ConcatOperation, context):
if self._has_invalid_type(expr.left):
self.generate(expr.left, context)
return
self._validate_children((expr.left, expr.right), context)
@generate.register
def _(self, expr: behav.Literal, context):
pass
@generate.register
def _(self, expr: behav.Tensor, context):
ty = expr.ty
self._validate_declared_sizes(ty, expr.line_info)
shape = []
shape_known = True
while isinstance(ty, type_info.ArrayType):
count = self._declared_size(ty.length, expr.line_info)
if not isinstance(count, int):
shape_known = False
else:
shape.append(count)
ty = ty.element_type
errors = []
if shape_known and shape and tuple(shape) != expr.value.shape:
errors.append(M2ValidationError('List initializer size does not match LHS size',
'InvalidAssignmentType', expr.line_info))
for element in getattr(expr, 'initializer_elements', None) or ():
try:
self.generate(element, context)
except M2ValidationError as error:
errors.append(error)
if isinstance(ty, type_info.PrimitiveType):
try:
self._validate_scalar_conversion(ty, element, context, element.line_info or expr.line_info)
except M2ValidationError as error:
errors.append(error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@staticmethod
[docs]
def _assignment_value(expr):
if getattr(expr, 'compound_operator', None) and isinstance(expr.expr, behav.BinaryOperation):
return expr.expr.right
return expr.expr
@generate.register
def _(self, expr: behav.Assignment, context):
errors = []
for child in (expr.target, self._assignment_value(expr)):
try:
self.generate(child, context)
except M2ValidationError as error:
errors.append(error)
try:
if not isinstance(expr.target, behav.VarDefinition):
self._validate_assignment_target(expr.target, expr.line_info)
except M2ValidationError as error:
errors.append(error)
try:
self._validate_assignment_types(
expr, context, emit_width_warnings=not errors and not getattr(expr, '_suppress_width_warnings', False))
except M2ValidationError as error:
errors.append(error)
operator = getattr(expr, 'compound_operator', None)
value = self._assignment_value(expr)
target_name = self._known_type_name(expr.target.ty)
value_name = self._known_type_name(value.ty)
if operator and not getattr(context, 'partial', False) and target_name is not None and value_name is not None:
integer_types = all(isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int
for ty in (expr.target.ty, value.ty))
if not integer_types:
errors.append(M2ValidationError(
f'Cannot combine {value_name} and {target_name} with the {operator[0]} operator',
'InvalidOperationType', expr.line_info))
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
[docs]
def _validate_assignment_types(self, expr, context, *, emit_width_warnings=True):
value = self._assignment_value(expr)
if self._has_invalid_type(expr.target) or self._has_invalid_type(value):
return
if expr.target.ty is None:
context.emit_warning("Missing infered assignment target type.", "incomplete-type-info", logger=logger, line_info=expr.target.line_info)
if value.ty is None:
context.emit_warning("Missing infered assignment expr type.", "incomplete-type-info", logger=logger, line_info=value.line_info)
assert expr.target.ty is not None
assert value.ty is not None
if isinstance(expr.target.ty, type_info.ArrayType) or isinstance(value.ty, type_info.ArrayType):
target = self._known_type_name(expr.target.ty)
source = self._known_type_name(value.ty)
if target is not None and source is not None and target != source:
raise M2ValidationError(f'Cannot implicitly convert {source} to {target}',
'InvalidAssignmentType', expr.line_info)
return
assert isinstance(expr.target.ty, type_info.PrimitiveType)
self._validate_scalar_conversion(expr.target.ty, value, context, expr.line_info)
if not emit_width_warnings:
return # Preserve collected semantic errors ahead of fatal warnings.
if arch.get_const_or_val(expr.target.ty.size) < arch.get_const_or_val(value.ty.size):
context.emit_warning(f"Implicit truncation {value.ty.size} -> {expr.target.ty.size} found", "implicit-trunc", logger=logger, line_info=expr.line_info)
if arch.get_const_or_val(expr.target.ty.size) > arch.get_const_or_val(value.ty.size):
context.emit_warning(f"Implicit extend {value.ty.size} -> {expr.target.ty.size} found", "implicit-extend", logger=logger, line_info=expr.line_info)
@generate.register
def _(self, expr: behav.Conditional, context):
errors = []
for cond in expr.conds:
try:
self.generate(cond, context)
self._validate_condition(cond)
except M2ValidationError as error:
errors.append(error)
for stmt in expr.stmts:
try:
self.generate(stmt, context)
except M2ValidationError as error:
errors.append(error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.LoopBase, context):
errors = []
for stmt in expr.init:
try:
self.generate(stmt, context)
except M2ValidationError as error:
errors.append(error)
try:
self.generate(expr.cond, context)
self._validate_condition(expr.cond)
except M2ValidationError as error:
errors.append(error)
previous_depth = getattr(self, '_loop_depth', 0)
self._loop_depth = previous_depth + 1
try:
for stmt in [*expr.stmts, *expr.updates]:
try:
self.generate(stmt, context)
except M2ValidationError as error:
errors.append(error)
finally:
self._loop_depth = previous_depth
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.Ternary, context):
errors = []
for child in (expr.cond, expr.then_expr, expr.else_expr):
try:
self.generate(child, context)
except M2ValidationError as error:
errors.append(error)
try:
self._validate_condition(expr.cond)
except M2ValidationError as error:
errors.append(error)
incompatible = self._incompatible_option_names(expr)
if (not self._has_invalid_type(expr.then_expr)
and not self._has_invalid_type(expr.else_expr)
and incompatible is not None):
then_name, else_name = incompatible
errors.append(M2ValidationError(
f'Incompatible option types: {then_name} and {else_name}',
'IncompatibleOptionTypes', expr.line_info))
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.Return, context):
errors = []
if expr.expr is not None:
try:
self.generate(expr.expr, context)
except M2ValidationError as error:
errors.append(error)
try:
function = getattr(context, 'function', None)
if function is None:
raise M2ValidationError('Return statement is only valid in a function',
'ReturnStatementOutsideFunction', expr.line_info)
target_type = type_info.PrimitiveType(function.ty.kind, function.ty.size)
if target_type.kind.is_void and expr.expr is not None:
raise M2ValidationError('Void functions may not return a value',
'ReturnWithValueInVoidFunction', expr.line_info)
if not target_type.kind.is_void and expr.expr is None:
raise M2ValidationError('Non-void functions must return a value',
'ReturnWithoutValueInNonVoidFunction', expr.line_info)
if expr.expr is not None and not self._has_invalid_type(expr.expr):
target, source = self._known_type_name(target_type), self._known_type_name(expr.expr.ty)
if target is not None and source is not None:
compatible = self._implicitly_convertible(expr.expr.ty, target_type)
if not compatible:
raise M2ValidationError(f'Cannot convert from {source} to {target}',
'ReturnTypeNotConvertible', expr.line_info)
except M2ValidationError as error:
errors.append(error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
return expr
@generate.register
def _(self, expr: behav.UnaryOperation, context):
errors = []
try:
self.generate(expr.right, context)
except M2ValidationError as error:
errors.append(error)
if expr.op.value in ('++', '--'):
try:
self._validate_assignment_target(expr.right, expr.line_info)
except M2ValidationError as error:
errors.append(error)
ty = getattr(expr.right, 'ty', None)
if self._known_type_name(ty) is not None and not (
isinstance(ty, type_info.PrimitiveType) and ty.kind.is_int):
errors.append(M2ValidationError('Increment and decrement operators are only valid on integer types',
'InvalidOperationType', expr.line_info))
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
return expr
@generate.register
def _(self, expr: behav.VarDefinition, context):
self._validate_declared_sizes(expr.var.ty, expr.line_info)
@generate.register
def _(self, expr: behav.Break, context):
if not getattr(self, '_loop_depth', 0) and not getattr(self, '_preserved_breaks_active', False):
raise M2ValidationError('Unexpected break statement', 'StrayControlFlowStatement', expr.line_info)
@generate.register
def _(self, expr: behav.Continue, context):
if not getattr(self, '_loop_depth', 0) and not getattr(self, '_preserved_continues_active', False):
raise M2ValidationError('Unexpected continue statement', 'StrayControlFlowStatement', expr.line_info)
@generate.register
def _(self, expr: behav.NamedReference, context):
pass
@generate.register
def _(self, expr: behav.IndexedReference, context):
children = [expr.index]
if expr.right is not None and expr.right is not expr.index:
children.append(expr.right)
self._validate_access(children, children, context,
getattr(expr.reference, "ty", None), expr.line_info,
(expr.index, expr.right) if expr.right is not None else None)
@generate.register
def _(self, expr: behav.TypeConv, context):
errors = []
target_type = None
try:
self.generate(expr.expr, context)
except M2ValidationError as error:
errors.append(error)
try:
source_type = expr.expr.ty
source_name = self._known_type_name(source_type)
source_integer = isinstance(source_type, type_info.PrimitiveType) and source_type.kind.is_int
if expr.size is None:
if source_integer:
target_type = type_info.PrimitiveType(expr.data_type, source_type.size)
if (not self._has_invalid_type(expr.expr)
and source_name is not None and not source_integer):
raise M2ValidationError('Cannot apply signedness cast to non-integer value',
'InvalidCast', expr.line_info)
else:
target_type = type_info.PrimitiveType(expr.data_type, expr.size)
self._validate_declared_sizes(target_type, expr.line_info)
target_name = self._known_type_name(target_type)
if (not self._has_invalid_type(expr.expr)
and source_name is not None and target_name is not None
and not (source_integer and expr.data_type.is_int)):
raise M2ValidationError(f'Cannot cast from {source_name} to {target_name}',
'InvalidCast', expr.line_info)
except M2ValidationError as error:
errors.append(error)
if (not getattr(context, 'source_validated', False)
and not self._has_invalid_type(expr.expr)
and source_name is not None
and source_name == self._known_type_name(target_type)):
try:
context.emit_warning('Identity cast does nothing', 'identity-cast',
logger=logger, line_info=expr.line_info)
except M2WarningError as warning:
if not errors:
raise
errors.append(M2ValidationError(str(warning), 'IdentityCast', expr.line_info))
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.Callable, context):
parameters = None
if isinstance(expr.ref_or_name, arch.Function):
parameters = list(expr.ref_or_name.args.values())
if len(parameters) != len(expr.args):
raise M2ValidationError(
f'Incorrect argument count. Expected {len(parameters)}, got {len(expr.args)}',
'InvalidArgumentCount', expr.line_info)
errors = []
for index, argument in enumerate(expr.args):
try:
self.generate(argument, context)
except M2ValidationError as error:
errors.append(error)
if parameters is not None:
try:
self._validate_scalar_conversion(parameters[index].ty, argument, context,
argument.line_info or expr.line_info, 'InvalidArgumentType')
except M2ValidationError as error:
errors.append(error)
if errors:
errors[0].related_diagnostics.extend(errors[1:])
raise errors[0]
@generate.register
def _(self, expr: behav.Group, context):
self.generate(expr.expr, context)