def get_pred(self):
if self.is_ninf():
return copy.deepcopy(self)
if self.is_pzero():
return Float('-0',ne=self.ne,ns=self.ns).get_pred()
bv_str = self.get_bv_str()
#print(bv_str)
sign = bv_str[0]
if sign == '0':
succ = int(bv_str[1:],2) - 1
return Float(val=z3.simplify(z3.fpBVToFP(z3.Int2BV(z3.IntVal(succ),num_bits = self.ns + self.ne),z3.FPSort(self.ne,self.ns))),ne=self.ne, ns=self.ns)
else:
succ = int(bv_str[1:],2) + 1
return -Float(val=z3.simplify(z3.fpBVToFP(z3.Int2BV(z3.IntVal(succ),num_bits = self.ns + self.ne),z3.FPSort(self.ne,self.ns))),ne=self.ne, ns=self.ns)
def prepare_float(val, signext=False, size=SIZE) -> z3.FPRef:
if z3.is_fp(val):
return val
size_class = z3.Float64()
if size == 32:
size_class = z3.Float32()
elif size == 128:
size_class = z3.Float128()
if type(val) in (int, float):
result = z3.FPVal(val)
else:
bv_val = prepare(val, signext, size)
result = z3.fpBVToFP(bv_val, size_class)
return result
def do_I2F(op, stack, state):
val, = pop_values(stack, state)
stack.append(z3.fpBVToFP(val, z3.Float64))
def interp(tree, lookup, z3_mode):
"""Evaluate the arithmetic expression.
Pass a tree as a Lark `Tree` object for the parsed expression. For
`lookup`, provide a function for mapping variable names to values.
"""
op = tree.data
if op in ('add', 'sub', 'mul', 'div', 'shl', 'shr'): # Binary operators.
lhs = interp(tree.children[0], lookup, z3_mode)
rhs = interp(tree.children[1], lookup, z3_mode)
if op == 'add':
return lhs + rhs
elif op == 'sub':
return lhs - rhs
elif op == 'mul':
return lhs * rhs
elif op == 'div':
return lhs / rhs
elif op == 'shl':
return lhs << rhs
elif op == 'shr':
return lhs >> rhs
elif op == 'neg': # Negation.
sub = interp(tree.children[0], lookup, z3_mode)
return -sub
elif op == 'int': # Literal number.
if z3_mode:
return z3.BitVecVal(int(tree.children[0]), 32)
else:
return int(tree.children[0])
elif op == 'float': # Literal number.
if z3_mode:
return z3.BitVecVal(float(tree.children[0]), 32)
else:
return float(tree.children[0])
elif op == 'var': # Variable lookup.
return lookup(tree.children[0])
elif op == 'if': # Conditional.
cond = interp(tree.children[0], lookup, z3_mode)
true = interp(tree.children[1], lookup, z3_mode)
false = interp(tree.children[2], lookup, z3_mode)
return (cond != 0) * true + (cond == 0) * false
elif op == "intcast":
child = interp(tree.children[0], lookup, z3_mode)
if z3_mode:
return z3.BV2Int(child)
else:
return int(child)
elif op == "floatcast":
child = interp(tree.children[0], lookup, z3_mode)
if z3_mode:
return z3.fpBVToFP(child, z3.Float32())
else:
return float(child)
elif op == "int2bv":
child = interp(tree.children[0], lookup, z3_mode)
if z3_mode:
return z3.Int2BV(child, 32)
else:
return child
elif op == "float2bv":
child = interp(tree.children[0], lookup, z3_mode)
if z3_mode:
return z3.fpToIEEEBV(child)
else:
return child
def _mk_nan(self):
bv = '0' + ('1' * self.ne) + ('1' * (self.ns -1))
val = int(bv,2)
self.__dict__ = copy.deepcopy(Float(val=z3.simplify(z3.fpBVToFP(z3.Int2BV(z3.IntVal(val),num_bits = self.ns + self.ne),z3.FPSort(self.ne,self.ns))),ne=self.ne, ns=self.ns).__dict__)
def _mk_pzero(self):
self.__dict__ = copy.deepcopy(Float(val=z3.simplify(z3.fpBVToFP(z3.Int2BV(z3.IntVal(0),num_bits = self.ns + self.ne),z3.FPSort(self.ne,self.ns))),ne=self.ne, ns=self.ns).__dict__)