def _sample_ops(self, x: value.Value) -> value.Value:
"""Runs a string of Value operations against the given value."""
return x.shrl(x).bitwise_xor(x).shra(x).bitwise_or(x).bitwise_and(x)\
.bitwise_negate().arithmetic_negate().sub(x)
def test_parse_args(self):
self.assertEqual(sample.parse_args(''), tuple())
self.assertEqual(
sample.parse_args('bits[8]:42'), (Value.make_ubits(8, 42),))
self.assertEqual(
sample.parse_args('bits[8]:42; bits[16]:1234'),
(Value.make_ubits(8, 42), Value.make_ubits(16, 1234)))
self.assertEqual(
sample.parse_args(
'bits[8]:42; (bits[8]:0x42, (bits[16]:0x33, bits[8]:0x44))'),
(Value.make_ubits(8, 42),
Value.make_tuple(
(Value.make_ubits(8, 0x42),
Value.make_tuple(
(Value.make_ubits(16, 0x33), Value.make_ubits(8, 0x44)))))))
self.assertEqual(
sample.parse_args('[bits[8]:0x42, bits[8]:0x43, bits[8]:0x44]'),
(Value.make_array(
tuple(Value.make_ubits(8, v) for v in (0x42, 0x43, 0x44))),))
def compare_values(interpreter_value: dslx_value.Value,
jit_value: ir_value.Value) -> None:
"""Asserts equality between a DSLX Value and an IR Value.
Recursively traverses the values (for arrays/tuples) and makes assertions
about value and length properties.
Args:
interpreter_value: Value that resulted from DSL interpretation.
jit_value: Value that resulted from JIT-compiled execution.
Raises:
JitMiscompareError: If the dslx_value and jit_value are not equivalent.
UnsupportedJitConversionError: If there is not JIT-supported type equivalent
for the interpreter value.
"""
if interpreter_value.is_bits() or interpreter_value.is_enum():
assert jit_value.is_bits(), f'Expected bits value: {jit_value!r}'
jit_value = jit_value.get_bits()
bit_count = interpreter_value.get_bit_count()
if bit_count != jit_value.bit_count():
raise JitMiscompareError(f'Inconsistent bit counts for value -- '
f'interp: {bit_count}, '
f'jit: {jit_value.bit_count()}')
if interpreter_value.is_ubits():
interpreter_bits_value = interpreter_value.get_bits_value()
jit_bits_value = bits_to_int(jit_value, signed=False)
else:
interpreter_bits_value = interpreter_value.get_bits_value_signed()
jit_bits_value = bits_to_int(jit_value, signed=True)
if interpreter_bits_value != jit_bits_value:
raise JitMiscompareError(
'Inconsistent bit values in return value -- '
'interp: {!r}, jit: {!r}'.format(interpreter_bits_value,
jit_bits_value))
elif interpreter_value.is_array():
assert jit_value.is_array(), f'Expected array value: {jit_value!r}'
interpreter_values = interpreter_value.array_payload.elements
jit_values = jit_value.get_elements()
interp_len = len(interpreter_values)
jit_len = len(jit_values)
if interp_len != jit_len:
raise JitMiscompareError(
f'Inconsistent array lengths in return value -- '
f'interp: {interp_len}, jit: {jit_len}')
for interpreter_element, jit_element in zip(interpreter_values,
jit_values):
compare_values(interpreter_element, jit_element)
elif interpreter_value.is_tuple():
assert jit_value.is_tuple(), 'Expected tuple value: {jit_value!r}'
interpreter_values = interpreter_value.tuple_members
jit_values = jit_value.get_elements()
interp_len = len(interpreter_values)
jit_len = len(jit_values)
if interp_len != jit_len:
raise JitMiscompareError(
f'Inconsistent tuple lengths in return value -- '
f'interp: {interp_len}, jit: {jit_len}')
for interpreter_element, jit_element in zip(interpreter_values,
jit_values):
compare_values(interpreter_element, jit_element)
else:
raise UnsupportedJitConversionError(
'No JIT-supported type equivalent: {}'.format(interpreter_value))