Exemple #1
0
 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)
Exemple #2
0
 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))),))
Exemple #3
0
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))