bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap1>));
BOOST_CONCEPT_ASSERT((boost::heap::PriorityQueue<Heap2>));
// if this assertion is triggered, the value_compare types are incompatible
BOOST_STATIC_ASSERT((boost::is_same<typename Heap1::value_compare, typename Heap2::value_compare>::value));
if (Heap1::constant_time_size && Heap2::constant_time_size)
if (lhs.size() != rhs.size())
return false;
if (lhs.empty() && rhs.empty())
return true;
Heap1 lhs_copy(lhs);
Heap2 rhs_copy(rhs);
while (true) {
if (!value_equality(lhs_copy, rhs_copy, lhs_copy.top(), rhs_copy.top()))
return false;
lhs_copy.pop();
rhs_copy.pop();
if (lhs_copy.empty() && rhs_copy.empty())
return true;
if (lhs_copy.empty())
return false;
if (rhs_copy.empty())
return false;
}
}
MyFloat MyFloat::operator+(const MyFloat& rhs) const{
int exponent_difference = 0;
int borrow = 0;
int i;
MyFloat float_copy(*this);
MyFloat rhs_copy(rhs);
float_copy.mantissa |= 1<<23; //restoreS leading bit for both mantissas
rhs_copy.mantissa |= 1<<23; //restore leading bit
if(float_copy.mantissa == rhs_copy.mantissa) // case if the number are the same, but the sign is opposite, just return 0 for 7 + -7, return 0;
if(float_copy.exponent == rhs_copy.exponent)
if(float_copy.sign != rhs_copy.sign)
return 0;
exponent_difference = rhs_copy.exponent - float_copy.exponent; // find difference between exponents
if (exponent_difference == 0)
{
}
else if(exponent_difference > 0) //rhs = 5*10^6 this = 32*10^4 = 2
{
float_copy.mantissa = float_copy.mantissa >> (exponent_difference -1); // right shift, since rhs is bigger than this
borrow = float_copy.mantissa & 1;
float_copy.mantissa = float_copy.mantissa >> 1;
float_copy.exponent += exponent_difference; //restore the same exponent
}
bool operator()(Heap1 const & lhs, Heap2 const & rhs)
{
typename Heap1::size_type left_size = lhs.size();
typename Heap2::size_type right_size = rhs.size();
if (left_size < right_size)
return true;
if (left_size > right_size)
return false;
Heap1 lhs_copy(lhs);
Heap2 rhs_copy(rhs);
while (true) {
if (value_compare(lhs_copy, rhs_copy, lhs_copy.top(), rhs_copy.top()))
return true;
if (value_compare(lhs_copy, rhs_copy, rhs_copy.top(), lhs_copy.top()))
return false;
lhs_copy.pop();
rhs_copy.pop();
if (lhs_copy.empty() && rhs_copy.empty())
return false;
}
}
expr2tc
goto_symext::symex_mem(
const bool is_malloc,
const expr2tc &lhs,
const sideeffect2t &code)
{
if (is_nil_expr(lhs))
return expr2tc(); // ignore
// size
type2tc type = code.alloctype;
expr2tc size = code.size;
bool size_is_one = false;
if (is_nil_expr(size))
size_is_one=true;
else
{
cur_state->rename(size);
mp_integer i;
if (is_constant_int2t(size) && to_constant_int2t(size).as_ulong() == 1)
size_is_one = true;
}
if (is_nil_type(type))
type = char_type2();
else if (is_union_type(type)) {
// Filter out creation of instantiated unions. They're now all byte arrays.
size_is_one = false;
type = char_type2();
}
unsigned int &dynamic_counter = get_dynamic_counter();
dynamic_counter++;
// value
symbolt symbol;
symbol.base_name = "dynamic_" + i2string(dynamic_counter) +
(size_is_one ? "_value" : "_array");
symbol.name = "symex_dynamic::" + id2string(symbol.base_name);
symbol.lvalue = true;
typet renamedtype = ns.follow(migrate_type_back(type));
if(size_is_one)
symbol.type=renamedtype;
else
{
symbol.type=typet(typet::t_array);
symbol.type.subtype()=renamedtype;
symbol.type.size(migrate_expr_back(size));
}
symbol.type.dynamic(true);
symbol.mode="C";
new_context.add(symbol);
type2tc new_type;
migrate_type(symbol.type, new_type);
address_of2tc rhs_addrof(get_empty_type(), expr2tc());
if(size_is_one)
{
rhs_addrof.get()->type = get_pointer_type(pointer_typet(symbol.type));
rhs_addrof.get()->ptr_obj = symbol2tc(new_type, symbol.name);
}
else
{
type2tc subtype;
migrate_type(symbol.type.subtype(), subtype);
expr2tc sym = symbol2tc(new_type, symbol.name);
expr2tc idx_val = zero_ulong;
expr2tc idx = index2tc(subtype, sym, idx_val);
rhs_addrof.get()->type =
get_pointer_type(pointer_typet(symbol.type.subtype()));
rhs_addrof.get()->ptr_obj = idx;
}
expr2tc rhs = rhs_addrof;
expr2tc ptr_rhs = rhs;
if (!options.get_bool_option("force-malloc-success")) {
symbol2tc null_sym(rhs->type, "NULL");
sideeffect2tc choice(get_bool_type(), expr2tc(), expr2tc(), std::vector<expr2tc>(), type2tc(), sideeffect2t::nondet);
rhs = if2tc(rhs->type, choice, rhs, null_sym);
replace_nondet(rhs);
ptr_rhs = rhs;
}
if (rhs->type != lhs->type)
rhs = typecast2tc(lhs->type, rhs);
cur_state->rename(rhs);
expr2tc rhs_copy(rhs);
guardt guard;
symex_assign_rec(lhs, rhs, guard);
pointer_object2tc ptr_obj(pointer_type2(), ptr_rhs);
track_new_pointer(ptr_obj, new_type);
dynamic_memory.push_back(allocated_obj(rhs_copy, cur_state->guard, !is_malloc));
return rhs_addrof->ptr_obj;
}
