def _fptosi(term, smt):
v = smt.eval(term.arg)
src = smt.type(term.arg)
tgt = smt.type(term)
m = 2**(tgt.width - 1)
# TODO: don't generate trivial conds
return smt._conditional_conv_value([v >= -m, v <= m - 1],
z3.fpToSBV(z3.RTZ(), v, _ty_sort(tgt)),
term.name)
def _fptosi(term, smt):
v = smt.eval(term.arg)
src = smt.type(term.arg)
tgt = smt.type(term)
m = 2**(tgt.width-1)
# TODO: don't generate trivial conds
return smt._conditional_conv_value(
[v >= -m, v <= m-1],
z3.fpToSBV(z3.RTZ(), v, _ty_sort(tgt)),
term.name)
def _op_raw_fpToSBV(self, rm, fp, bv_len):
return z3.fpToSBV(rm, fp, z3.BitVecSort(bv_len, ctx=self._context))
def _op_raw_fpToSBV(self, rm, fp, bv_len):
return z3.fpToSBV(rm, fp, z3.BitVecSort(bv_len, ctx=self._context))
def fpToSBV(rm, fp, bv_len):
return z3.fpToSBV(rm, fp, z3.BitVecSort(bv_len))
def cast(self, value, is_type, to_type):
if is_type is Types.STRING and isinstance(to_type,
z3.z3.DatatypeSortRef):
# the value is a string and it should be cast to a datatyperef
# (i.e. an enum-type), just return the value because we can deal with it
return value
value_is_int = isinstance(value, int)
value_is_float = isinstance(value, float)
if is_type is to_type: # already correct type, just return the value
return value
""" INT <---> INTEGER """
elif is_type is Types.INT and to_type is Types.INTEGER:
if value_is_int or value_is_float:
return value # this happens if it is an int numeral (e.g. 2)
else:
return z3.BV2Int(value)
elif is_type is Types.INTEGER and to_type is Types.INT:
if value_is_int or value_is_float:
return value
else:
return z3.Int2BV(value, 32)
""" INT <---> FLOAT """
elif is_type is Types.FLOAT and to_type is Types.INT:
if value_is_float:
return value # this happens if it is a float numeral (e.g. 3.14)
else:
return z3.fpToSBV(z3.RNE(), value, z3.BitVecSort(32))
elif is_type is Types.INT and to_type is Types.FLOAT:
if value_is_int:
return value
else:
return z3.fpSignedToFP(z3.RNE(), value, z3.Float32())
""" INTEGER <---> FLOAT """
elif is_type is Types.FLOAT and to_type is Types.INTEGER:
if value_is_float:
return value # this happens if it is a float numeral (e.g. 3.14)
else:
return self.cast(self.cast(value, Types.FLOAT, Types.INT),
Types.INT, Types.INTEGER)
elif is_type is Types.INTEGER and to_type is Types.FLOAT:
if value_is_int:
return value
else:
return self.cast(self.cast(value, Types.INTEGER, Types.INT),
Types.INT, Types.FLOAT)
""" from REAL """
elif is_type is Types.REAL and to_type is Types.INTEGER:
if value_is_float:
return value
else:
return z3.ToInt(value)
elif is_type is Types.REAL and to_type is Types.INT:
return self.cast(self.cast(value, Types.REAL, Types.INTEGER),
Types.INTEGER, Types.INT)
elif is_type is Types.REAL and to_type is Types.FLOAT:
"""
Rounding modes: probably should make these parameterizable!
roundNearestTiesToEven ... RNE() = default
roundNearestTiesToAway ... RNA()
roundTowardPositive ...... RTP()
roundTowardNegative ...... RTN()
roundTowardZero .......... RTZ()
"""
if value_is_int or value_is_float: # int numeral
return value
else:
return z3.fpRealToFP(z3.RNE(), value, z3.Float32())
""" to REAL """
elif is_type is Types.INT and to_type is Types.REAL:
if value_is_int or value_is_float: # int numeral
return value
else:
return z3.ToReal(self.cast(value, Types.INT, Types.INTEGER))
elif is_type is Types.INTEGER and to_type is Types.REAL:
if value_is_int or value_is_float: # int numeral
return value
else:
return z3.ToReal(value)
elif is_type is Types.FLOAT and to_type is Types.REAL:
if value_is_int or value_is_float:
return value # this happens if it is a float numeral (e.g. 3.14)
else:
return z3.fpToReal(value)
""" FROM BOOL conversions """
elif is_type is Types.BOOL and to_type is Types.INT:
return z3.If(value, z3.BitVecVal(1, 32), z3.BitVecVal(0, 32))
elif is_type is Types.BOOL and to_type is Types.INTEGER:
return z3.If(value, 1, 0)
elif is_type is Types.BOOL and to_type is Types.REAL:
return z3.If(value, 1.0, 0.0)
elif is_type is Types.BOOL and to_type is Types.FLOAT:
return z3.If(value, z3.FPVal(1.0, z3.Float32()),
z3.FPVal(0.0, z3.Float32()))
""" TO BOOL conversions """
elif is_type is Types.INT and to_type is Types.BOOL:
return value == 1
elif is_type is Types.INTEGER and to_type is Types.BOOL:
return value == 1
elif is_type is Types.REAL and to_type is Types.BOOL:
return value == 1
elif is_type is Types.FLOAT and to_type is Types.BOOL:
return value == 1
raise TypeError(f"Don't know how to cast from {is_type} to {to_type}!")
def _fptosi(term, smt): x = smt.eval(term._args[0]) tgt = smt.type(term) return z3.fpToSBV(z3.RTZ(), x, _ty_sort(tgt))
def _fptosi(term, smt):
x = smt.eval(term._args[0])
tgt = smt.type(term)
return z3.fpToSBV(z3.RTZ(), x, _ty_sort(tgt))