"""Pure evaluation of the release's integer constant subset in model nodes."""
import operator
from ...metamodel import arch, behav, type_info
from ...frontends.coredsl2.constant_expressions import cast_integer
[docs]
INDETERMINATE = object()
[docs]
BINARY = {'+': operator.add, '-': operator.sub, '*': operator.mul,
'&': operator.and_, '|': operator.or_, '^': operator.xor,
'%': operator.mod,
'==': operator.eq, '!=': operator.ne, '<': operator.lt,
'<=': operator.le, '>': operator.gt, '>=': operator.ge}
[docs]
def constant_value(node, active=frozenset(), on_error=None, *, allow_casts=False):
if isinstance(node, arch.Parameter):
if id(node) in active or node._value is None:
return INDETERMINATE
if isinstance(node._value, int):
return node._value
return constant_value(node._value, active | {id(node)}, on_error, allow_casts=allow_casts)
if isinstance(node, behav.Literal):
if isinstance(node.ty, type_info.PrimitiveType) and node.ty.kind.is_int:
return int(node.value)
if isinstance(node, behav.NamedReference) and isinstance(node.reference, arch.Parameter):
return constant_value(node.reference, active, on_error, allow_casts=allow_casts)
if isinstance(node, behav.Group):
return constant_value(node.expr, active, on_error, allow_casts=allow_casts)
if allow_casts and isinstance(node, behav.TypeConv):
value = constant_value(node.expr, active, on_error, allow_casts=allow_casts)
if value is None or value is INDETERMINATE:
return value
width = arch.get_const_or_val(node.size if node.size is not None else getattr(node.expr.ty, 'size', None))
if not isinstance(width, int) or width <= 0:
return None
try:
return cast_integer(value, width, node.data_type == type_info.TypeKind.INT)
except ValueError:
return None
if isinstance(node, behav.UnaryOperation) and node.op.value in ('-', '~', '!'):
value = constant_value(node.right, active, on_error, allow_casts=allow_casts)
if value is None or value is INDETERMINATE:
return value
if node.op.value == '-':
return -value
if node.op.value == '~':
return ~value
return int(not bool(value))
if isinstance(node, behav.BinaryOperation):
op = node.op.value
left = constant_value(node.left, active, on_error, allow_casts=allow_casts)
right = constant_value(node.right, active, on_error, allow_casts=allow_casts)
if left is None or right is None:
return None
if left is INDETERMINATE or right is INDETERMINATE:
return INDETERMINATE
if op not in BINARY and op not in ('/', '<<', '>>'):
return None
if op in BINARY:
if op == '%' and right == 0:
error = ZeroDivisionError('Modulo by zero')
if on_error is not None:
on_error(node, error)
return None
raise error
return int(BINARY[op](left, right))
if op == '/':
if right == 0:
error = ZeroDivisionError('Division by zero')
if on_error is not None:
on_error(node, error)
return None
raise error
value = abs(left) // abs(right)
return -value if (left < 0) != (right < 0) else value
if abs(right) > 100000:
return None
shift = -right if op == '>>' else right
return left << shift if shift >= 0 else left >> -shift
return None
[docs]
def holds_value(ty, value):
width = arch.get_const_or_val(ty.size)
if ty.kind == type_info.TypeKind.INT:
return (max(1, value.bit_length()) if value >= 0 else (~value).bit_length()) < width
return value >= 0 and value.bit_length() <= width
[docs]
def range_size(start, end, suppress_errors=True, on_error=None):
def evaluate(node):
try:
return constant_value(node, on_error=on_error)
except ZeroDivisionError as error:
if on_error is not None:
on_error(node, error)
elif not suppress_errors:
raise
return None
def relative_bound(node):
while isinstance(node, behav.Group):
node = node.expr
if isinstance(node, behav.NamedReference):
return node.reference, 0
if (isinstance(node, behav.BinaryOperation) and node.op.value in ('+', '-')
and isinstance(node.left, behav.NamedReference)):
return node.left.reference, (node.op.value, node.right)
return None
start_relative, end_relative = relative_bound(start), relative_bound(end)
if start_relative is not None and end_relative is not None:
if start_relative[0] is end_relative[0]:
def offset_value(relative):
offset = relative[1]
if isinstance(offset, int):
return offset
value = evaluate(offset[1])
if not isinstance(value, int):
return None
return value if offset[0] == '+' else -value
first_offset, last_offset = offset_value(start_relative), offset_value(end_relative)
if first_offset is None or last_offset is None:
return None
return abs(last_offset - first_offset) + 1
return None
first, last = evaluate(start), evaluate(end)
return abs(last - first) + 1 if isinstance(first, int) and isinstance(last, int) else None