def ir_value_to_interpreter_value(value: ir_value_mod.Value) -> Value: """Converts an IR Value to an interpreter Value.""" if value.is_bits(): if value.get_bits().bit_count() <= 64: return Value.make_ubits(value.get_bits().bit_count(), value.get_bits().to_uint()) else: # For wide values which do not fit in 64 bits, parse value as as string. return value_from_string(value.to_str(FormatPreference.HEX)) elif value.is_array(): return Value.make_array( tuple(ir_value_to_interpreter_value(e) for e in value.get_elements())) else: assert value.is_tuple() return Value.make_tuple( tuple(ir_value_to_interpreter_value(e) for e in value.get_elements()))
def ir_value_to_interpreter_value(value: ir_value_mod.Value) -> Value: """Converts an IR Value to an interpreter Value.""" if value.is_bits(): return Value.make_bits(Tag.UBITS, value.get_bits()) elif value.is_array(): return Value.make_array( tuple(ir_value_to_interpreter_value(e) for e in value.get_elements())) else: assert value.is_tuple() return Value.make_tuple( tuple(ir_value_to_interpreter_value(e) for e in value.get_elements()))
def ir_value_to_interpreter_value(value: ir_value.Value, dslx_type: ConcreteType) -> dslx_value.Value: """Converts an IR Value to an interpreter Value.""" if value.is_bits(): assert isinstance(dslx_type, BitsType), dslx_type ir_bits_val = value.get_bits() if dslx_type.get_signedness(): return dslx_value.Value.make_sbits(ir_bits_val) return dslx_value.Value.make_ubits(ir_bits_val) elif value.is_array(): assert isinstance(dslx_type, ArrayType), dslx_type return dslx_value.Value.make_array( tuple( ir_value_to_interpreter_value(e, dslx_type.element_type) for e in value.get_elements())) else: assert value.is_tuple() assert isinstance(dslx_type, TupleType), dslx_type return dslx_value.Value.make_tuple( tuple( ir_value_to_interpreter_value(e, t) for e, t in zip( value.get_elements(), dslx_type.get_unnamed_members())))
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))