void boolbvt::convert_constant(const constant_exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
bv.resize(width);
const typet &expr_type=expr.type();
if(expr_type.id()==ID_array)
{
unsigned op_width=width/expr.operands().size();
unsigned offset=0;
forall_operands(it, expr)
{
const bvt &tmp=convert_bv(*it);
if(tmp.size()!=op_width)
throw "convert_constant: unexpected operand width";
for(unsigned j=0; j<op_width; j++)
bv[offset+j]=tmp[j];
offset+=op_width;
}
return;
}
void boolbvt::convert_replication(const exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
if(expr.operands().size()!=2)
throw "replication takes two operands";
mp_integer times;
if(to_integer(expr.op0(), times))
throw "replication takes constant as first parameter";
const unsigned u_times=integer2unsigned(times);
const bvt &op=convert_bv(expr.op1());
unsigned offset=0;
bv.resize(width);
for(unsigned i=0; i<u_times; i++)
{
if(op.size()+offset>width)
throw "replication operand width too big";
for(unsigned i=0; i<op.size(); i++)
bv[i+offset]=op[i];
offset+=op.size();
}
if(offset!=bv.size())
throw "replication operand width too small";
}
void boolbvt::convert_concatenation(const exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
const exprt::operandst &operands=expr.operands();
if(operands.size()==0)
throw "concatenation takes at least one operand";
unsigned offset=width;
bv.resize(width);
forall_expr(it, operands)
{
const bvt &op=convert_bv(*it);
if(op.size()>offset)
throw "concatenation operand width too big";
offset-=op.size();
for(unsigned i=0; i<op.size(); i++)
bv[offset+i]=op[i];
}
if(offset!=0)
throw "concatenation operand width too small";
}
void boolbvt::convert_index(
const exprt &array,
const mp_integer &index,
bvt &bv)
{
const array_typet &array_type=
to_array_type(ns.follow(array.type()));
unsigned width=boolbv_width(array_type.subtype());
if(width==0)
return conversion_failed(array, bv);
bv.resize(width);
const bvt &tmp=convert_bv(array); // recursive call
mp_integer offset=index*width;
if(offset>=0 &&
offset+width<=mp_integer(tmp.size()))
{
// in bounds
for(unsigned i=0; i<width; i++)
bv[i]=tmp[integer2long(offset+i)];
}
else
{
// out of bounds
for(unsigned i=0; i<width; i++)
bv[i]=prop.new_variable();
}
}
void boolbvt::convert_with(
const typet &type,
const exprt &op1,
const exprt &op2,
const bvt &prev_bv,
bvt &next_bv)
{
// we only do that on arrays, bitvectors, structs, and unions
next_bv.resize(prev_bv.size());
if(type.id()==ID_array)
return convert_with_array(to_array_type(type), op1, op2, prev_bv, next_bv);
else if(type.id()==ID_bv ||
type.id()==ID_unsignedbv ||
type.id()==ID_signedbv)
return convert_with_bv(type, op1, op2, prev_bv, next_bv);
else if(type.id()==ID_struct)
return convert_with_struct(to_struct_type(type), op1, op2, prev_bv, next_bv);
else if(type.id()==ID_union)
return convert_with_union(to_union_type(type), op1, op2, prev_bv, next_bv);
else if(type.id()==ID_symbol)
return convert_with(ns.follow(type), op1, op2, prev_bv, next_bv);
error().source_location=type.source_location();
error() << "unexpected with type: " << type.id();
throw 0;
}
void boolbvt::convert_cond(const exprt &expr, bvt &bv)
{
const exprt::operandst &operands=expr.operands();
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
bv.resize(width);
// make it free variables
Forall_literals(it, bv)
*it=prop.new_variable();
if(operands.size()<2)
throw "cond takes at least two operands";
if((operands.size()%2)!=0)
throw "number of cond operands must be even";
if(prop.has_set_to())
{
bool condition=true;
literalt previous_cond=const_literal(false);
literalt cond_literal=const_literal(false);
forall_operands(it, expr)
{
if(condition)
{
cond_literal=convert(*it);
cond_literal=prop.land(prop.lnot(previous_cond), cond_literal);
previous_cond=prop.lor(previous_cond, cond_literal);
}
else
{
const bvt &op=convert_bv(*it);
if(bv.size()!=op.size())
{
std::cerr << "result size: " << bv.size()
<< std::endl
<< "operand: " << op.size() << std::endl
<< it->pretty()
<< std::endl;
throw "size of value operand does not match";
}
literalt value_literal=bv_utils.equal(bv, op);
prop.l_set_to_true(prop.limplies(cond_literal, value_literal));
}
condition=!condition;
}
}
void boolbvt::convert_union(const exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
if(expr.operands().size()!=1)
throw "union expects one argument";
const bvt &op_bv=convert_bv(expr.op0());
if(width<op_bv.size())
throw "union: unexpected operand op width";
bv.resize(width);
for(unsigned i=0; i<op_bv.size(); i++)
bv[i]=op_bv[i];
// pad with nondets
for(unsigned i=op_bv.size(); i<bv.size(); i++)
bv[i]=prop.new_variable();
}
void boolbvt::convert_mult(const exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
bv.resize(width);
const exprt::operandst &operands=expr.operands();
if(operands.size()==0)
throw "mult without operands";
const exprt &op0=expr.op0();
bool no_overflow=expr.id()=="no-overflow-mult";
if(expr.type().id()==ID_fixedbv)
{
if(op0.type()!=expr.type())
throw "multiplication with mixed types";
bv=convert_bv(op0);
if(bv.size()!=width)
throw "convert_mult: unexpected operand width";
unsigned fraction_bits=
to_fixedbv_type(expr.type()).get_fraction_bits();
// do a sign extension by fraction_bits bits
bv=bv_utils.sign_extension(bv, bv.size()+fraction_bits);
for(exprt::operandst::const_iterator it=operands.begin()+1;
it!=operands.end(); it++)
{
if(it->type()!=expr.type())
throw "multiplication with mixed types";
bvt op=convert_bv(*it);
if(op.size()!=width)
throw "convert_mult: unexpected operand width";
op=bv_utils.sign_extension(op, bv.size());
bv=bv_utils.signed_multiplier(bv, op);
}
// cut it down again
bv.erase(bv.begin(), bv.begin()+fraction_bits);
return;
}
else if(expr.type().id()==ID_floatbv)
{
if(op0.type()!=expr.type())
throw "multiplication with mixed types";
bv=convert_bv(op0);
if(bv.size()!=width)
throw "convert_mult: unexpected operand width";
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(expr.type());
for(exprt::operandst::const_iterator it=operands.begin()+1;
it!=operands.end(); it++)
{
if(it->type()!=expr.type())
throw "multiplication with mixed types";
const bvt &op=convert_bv(*it);
if(op.size()!=width)
throw "convert_mult: unexpected operand width";
bv=float_utils.mul(bv, op);
}
return;
}
else if(expr.type().id()==ID_unsignedbv ||
expr.type().id()==ID_signedbv)
{
if(op0.type()!=expr.type())
throw "multiplication with mixed types";
bv_utilst::representationt rep=
expr.type().id()==ID_signedbv?bv_utilst::SIGNED:
bv_utilst::UNSIGNED;
bv=convert_bv(op0);
if(bv.size()!=width)
throw "convert_mult: unexpected operand width";
for(exprt::operandst::const_iterator it=operands.begin()+1;
it!=operands.end(); it++)
{
if(it->type()!=expr.type())
throw "multiplication with mixed types";
const bvt &op=convert_bv(*it);
if(op.size()!=width)
throw "convert_mult: unexpected operand width";
if(no_overflow)
bv=bv_utils.multiplier_no_overflow(bv, op, rep);
else
bv=bv_utils.multiplier(bv, op, rep);
}
return;
}
conversion_failed(expr, bv);
}
void boolbvt::convert_add_sub(const exprt &expr, bvt &bv)
{
const typet &type=ns.follow(expr.type());
if(type.id()!=ID_unsignedbv &&
type.id()!=ID_signedbv &&
type.id()!=ID_fixedbv &&
type.id()!=ID_floatbv &&
type.id()!=ID_range &&
type.id()!=ID_vector)
return conversion_failed(expr, bv);
unsigned width=boolbv_width(type);
if(width==0)
return conversion_failed(expr, bv);
const exprt::operandst &operands=expr.operands();
if(operands.size()==0)
throw "operand "+expr.id_string()+" takes at least one operand";
const exprt &op0=expr.op0();
if(op0.type()!=type)
{
std::cerr << expr.pretty() << std::endl;
throw "add/sub with mixed types";
}
convert_bv(op0, bv);
if(bv.size()!=width)
throw "convert_add_sub: unexpected operand 0 width";
bool subtract=(expr.id()==ID_minus ||
expr.id()=="no-overflow-minus");
bool no_overflow=(expr.id()=="no-overflow-plus" ||
expr.id()=="no-overflow-minus");
typet arithmetic_type=
(type.id()==ID_vector)?ns.follow(type.subtype()):type;
bv_utilst::representationt rep=
(arithmetic_type.id()==ID_signedbv ||
arithmetic_type.id()==ID_fixedbv)?bv_utilst::SIGNED:
bv_utilst::UNSIGNED;
for(exprt::operandst::const_iterator
it=operands.begin()+1;
it!=operands.end(); it++)
{
if(it->type()!=type)
{
std::cerr << expr.pretty() << std::endl;
throw "add/sub with mixed types";
}
bvt op;
convert_bv(*it, op);
if(op.size()!=width)
throw "convert_add_sub: unexpected operand width";
if(type.id()==ID_vector)
{
const typet &subtype=ns.follow(type.subtype());
unsigned sub_width=boolbv_width(subtype);
if(sub_width==0 || width%sub_width!=0)
throw "convert_add_sub: unexpected vector operand width";
unsigned size=width/sub_width;
bv.resize(width);
for(unsigned i=0; i<size; i++)
{
bvt tmp_op;
tmp_op.resize(sub_width);
for(unsigned j=0; j<tmp_op.size(); j++)
{
assert(i*sub_width+j<op.size());
tmp_op[j]=op[i*sub_width+j];
}
bvt tmp_result;
tmp_result.resize(sub_width);
for(unsigned j=0; j<tmp_result.size(); j++)
{
assert(i*sub_width+j<bv.size());
tmp_result[j]=bv[i*sub_width+j];
}
if(type.subtype().id()==ID_floatbv)
{
#ifdef HAVE_FLOATBV
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(subtype);
tmp_result=float_utils.add_sub(tmp_result, tmp_op, subtract);
#else
return conversion_failed(expr, bv);
#endif
}
else
tmp_result=bv_utils.add_sub(tmp_result, tmp_op, subtract);
assert(tmp_result.size()==sub_width);
for(unsigned j=0; j<tmp_result.size(); j++)
{
assert(i*sub_width+j<bv.size());
bv[i*sub_width+j]=tmp_result[j];
}
}
}
else if(type.id()==ID_floatbv)
{
#ifdef HAVE_FLOATBV
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(arithmetic_type);
bv=float_utils.add_sub(bv, op, subtract);
#else
return conversion_failed(expr, bv);
#endif
}
else if(no_overflow)
bv=bv_utils.add_sub_no_overflow(bv, op, subtract, rep);
else
bv=bv_utils.add_sub(bv, op, subtract);
}
}
bool boolbvt::type_conversion(
const typet &src_type, const bvt &src,
const typet &dest_type, bvt &dest)
{
bvtypet dest_bvtype=get_bvtype(dest_type);
bvtypet src_bvtype=get_bvtype(src_type);
if(src_bvtype==IS_C_BIT_FIELD)
return type_conversion(
c_bit_field_replacement_type(to_c_bit_field_type(src_type), ns), src, dest_type, dest);
if(dest_bvtype==IS_C_BIT_FIELD)
return type_conversion(
src_type, src, c_bit_field_replacement_type(to_c_bit_field_type(dest_type), ns), dest);
std::size_t src_width=src.size();
std::size_t dest_width=boolbv_width(dest_type);
if(dest_width==0 || src_width==0)
return true;
dest.clear();
dest.reserve(dest_width);
if(dest_type.id()==ID_complex)
{
if(src_type==dest_type.subtype())
{
forall_literals(it, src)
dest.push_back(*it);
// pad with zeros
for(std::size_t i=src.size(); i<dest_width; i++)
dest.push_back(const_literal(false));
return false;
}
else if(src_type.id()==ID_complex)
{
// recursively do both halfs
bvt lower, upper, lower_res, upper_res;
lower.assign(src.begin(), src.begin()+src.size()/2);
upper.assign(src.begin()+src.size()/2, src.end());
type_conversion(ns.follow(src_type.subtype()), lower, ns.follow(dest_type.subtype()), lower_res);
type_conversion(ns.follow(src_type.subtype()), upper, ns.follow(dest_type.subtype()), upper_res);
assert(lower_res.size()+upper_res.size()==dest_width);
dest=lower_res;
dest.insert(dest.end(), upper_res.begin(), upper_res.end());
return false;
}
}
if(src_type.id()==ID_complex)
{
assert(dest_type.id()!=ID_complex);
if(dest_type.id()==ID_signedbv ||
dest_type.id()==ID_unsignedbv ||
dest_type.id()==ID_floatbv ||
dest_type.id()==ID_fixedbv ||
dest_type.id()==ID_c_enum ||
dest_type.id()==ID_c_enum_tag ||
dest_type.id()==ID_bool)
{
// A cast from complex x to real T
// is (T) __real__ x.
bvt tmp_src(src);
tmp_src.resize(src.size()/2); // cut off imag part
return type_conversion(src_type.subtype(), tmp_src, dest_type, dest);
}
}
switch(dest_bvtype)
{
case IS_RANGE:
if(src_bvtype==IS_UNSIGNED ||
src_bvtype==IS_SIGNED ||
src_bvtype==IS_C_BOOL)
{
mp_integer dest_from=to_range_type(dest_type).get_from();
if(dest_from==0)
{
// do zero extension
dest.resize(dest_width);
for(std::size_t i=0; i<dest.size(); i++)
dest[i]=(i<src.size()?src[i]:const_literal(false));
return false;
}
}
else if(src_bvtype==IS_RANGE) // range to range
{
mp_integer src_from=to_range_type(src_type).get_from();
mp_integer dest_from=to_range_type(dest_type).get_from();
if(dest_from==src_from)
{
// do zero extension, if needed
dest=bv_utils.zero_extension(src, dest_width);
return false;
}
else
{
// need to do arithmetic: add src_from-dest_from
mp_integer offset=src_from-dest_from;
dest=
bv_utils.add(
bv_utils.zero_extension(src, dest_width),
bv_utils.build_constant(offset, dest_width));
}
return false;
}
break;
case IS_FLOAT: // to float
{
float_utilst float_utils(prop);
switch(src_bvtype)
{
case IS_FLOAT: // float to float
// we don't have a rounding mode here,
// which is why we refuse.
break;
case IS_SIGNED: // signed to float
case IS_C_ENUM:
float_utils.spec=to_floatbv_type(dest_type);
dest=float_utils.from_signed_integer(src);
return false;
case IS_UNSIGNED: // unsigned to float
case IS_C_BOOL: // _Bool to float
float_utils.spec=to_floatbv_type(dest_type);
dest=float_utils.from_unsigned_integer(src);
return false;
case IS_BV:
assert(src_width==dest_width);
dest=src;
return false;
default:
if(src_type.id()==ID_bool)
{
// bool to float
// build a one
ieee_floatt f;
f.spec=to_floatbv_type(dest_type);
f.from_integer(1);
dest=convert_bv(f.to_expr());
assert(src_width==1);
Forall_literals(it, dest)
*it=prop.land(*it, src[0]);
return false;
}
}
}
break;
case IS_FIXED:
if(src_bvtype==IS_FIXED)
{
// fixed to fixed
std::size_t dest_fraction_bits=to_fixedbv_type(dest_type).get_fraction_bits(),
dest_int_bits=dest_width-dest_fraction_bits;
std::size_t op_fraction_bits=to_fixedbv_type(src_type).get_fraction_bits(),
op_int_bits=src_width-op_fraction_bits;
dest.resize(dest_width);
// i == position after dot
// i == 0: first position after dot
for(std::size_t i=0; i<dest_fraction_bits; i++)
{
// position in bv
std::size_t p=dest_fraction_bits-i-1;
if(i<op_fraction_bits)
dest[p]=src[op_fraction_bits-i-1];
else
dest[p]=const_literal(false); // zero padding
}
for(std::size_t i=0; i<dest_int_bits; i++)
{
// position in bv
std::size_t p=dest_fraction_bits+i;
assert(p<dest_width);
if(i<op_int_bits)
dest[p]=src[i+op_fraction_bits];
else
dest[p]=src[src_width-1]; // sign extension
}
return false;
}
else if(src_bvtype==IS_BV)
{
assert(src_width==dest_width);
dest=src;
return false;
}
else if(src_bvtype==IS_UNSIGNED ||
src_bvtype==IS_SIGNED ||
src_bvtype==IS_C_BOOL ||
src_bvtype==IS_C_ENUM)
{
// integer to fixed
std::size_t dest_fraction_bits=
to_fixedbv_type(dest_type).get_fraction_bits();
for(std::size_t i=0; i<dest_fraction_bits; i++)
dest.push_back(const_literal(false)); // zero padding
for(std::size_t i=0; i<dest_width-dest_fraction_bits; i++)
{
literalt l;
if(i<src_width)
l=src[i];
else
{
if(src_bvtype==IS_SIGNED || src_bvtype==IS_C_ENUM)
l=src[src_width-1]; // sign extension
else
l=const_literal(false); // zero extension
}
dest.push_back(l);
}
return false;
}
else if(src_type.id()==ID_bool)
{
// bool to fixed
std::size_t fraction_bits=
to_fixedbv_type(dest_type).get_fraction_bits();
assert(src_width==1);
for(std::size_t i=0; i<dest_width; i++)
{
if(i==fraction_bits)
dest.push_back(src[0]);
else
dest.push_back(const_literal(false));
}
return false;
}
break;
case IS_UNSIGNED:
case IS_SIGNED:
case IS_C_ENUM:
switch(src_bvtype)
{
case IS_FLOAT: // float to integer
// we don't have a rounding mode here,
// which is why we refuse.
break;
case IS_FIXED: // fixed to integer
{
std::size_t op_fraction_bits=
to_fixedbv_type(src_type).get_fraction_bits();
for(std::size_t i=0; i<dest_width; i++)
{
if(i<src_width-op_fraction_bits)
dest.push_back(src[i+op_fraction_bits]);
else
{
if(dest_bvtype==IS_SIGNED)
dest.push_back(src[src_width-1]); // sign extension
else
dest.push_back(const_literal(false)); // zero extension
}
}
// we might need to round up in case of negative numbers
// e.g., (int)(-1.00001)==1
bvt fraction_bits_bv=src;
fraction_bits_bv.resize(op_fraction_bits);
literalt round_up=
prop.land(prop.lor(fraction_bits_bv), src.back());
dest=bv_utils.incrementer(dest, round_up);
return false;
}
case IS_UNSIGNED: // integer to integer
case IS_SIGNED:
case IS_C_ENUM:
case IS_C_BOOL:
{
// We do sign extension for any source type
// that is signed, independently of the
// destination type.
// E.g., ((short)(ulong)(short)-1)==-1
bool sign_extension=
src_bvtype==IS_SIGNED || src_bvtype==IS_C_ENUM;
for(std::size_t i=0; i<dest_width; i++)
{
if(i<src_width)
dest.push_back(src[i]);
else if(sign_extension)
dest.push_back(src[src_width-1]); // sign extension
else
dest.push_back(const_literal(false));
}
return false;
}
case IS_VERILOG_UNSIGNED: // verilog_unsignedbv to signed/unsigned/enum
{
for(std::size_t i=0; i<dest_width; i++)
{
std::size_t src_index=i*2; // we take every second bit
if(src_index<src_width)
dest.push_back(src[src_index]);
else // always zero-extend
dest.push_back(const_literal(false));
}
return false;
}
break;
case IS_VERILOG_SIGNED: // verilog_signedbv to signed/unsigned/enum
{
for(std::size_t i=0; i<dest_width; i++)
{
std::size_t src_index=i*2; // we take every second bit
if(src_index<src_width)
dest.push_back(src[src_index]);
else // always sign-extend
dest.push_back(src.back());
}
return false;
}
break;
default:
if(src_type.id()==ID_bool)
{
// bool to integer
assert(src_width==1);
for(std::size_t i=0; i<dest_width; i++)
{
if(i==0)
dest.push_back(src[0]);
else
dest.push_back(const_literal(false));
}
return false;
}
}
break;
case IS_VERILOG_UNSIGNED:
if(src_bvtype==IS_UNSIGNED ||
src_bvtype==IS_C_BOOL ||
src_type.id()==ID_bool)
{
for(std::size_t i=0, j=0; i<dest_width; i+=2, j++)
{
if(j<src_width)
dest.push_back(src[j]);
else
dest.push_back(const_literal(false));
dest.push_back(const_literal(false));
}
return false;
}
else if(src_bvtype==IS_SIGNED)
{
for(std::size_t i=0, j=0; i<dest_width; i+=2, j++)
{
if(j<src_width)
dest.push_back(src[j]);
else
dest.push_back(src.back());
dest.push_back(const_literal(false));
}
return false;
}
else if(src_bvtype==IS_VERILOG_UNSIGNED)
{
// verilog_unsignedbv to verilog_unsignedbv
dest=src;
if(dest_width<src_width)
dest.resize(dest_width);
else
{
dest=src;
while(dest.size()<dest_width)
{
dest.push_back(const_literal(false));
dest.push_back(const_literal(false));
}
}
return false;
}
break;
case IS_BV:
assert(src_width==dest_width);
dest=src;
return false;
case IS_C_BOOL:
dest.resize(dest_width, const_literal(false));
if(src_bvtype==IS_FLOAT)
{
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(src_type);
dest[0]=!float_utils.is_zero(src);
}
else if(src_bvtype==IS_C_BOOL)
dest[0]=src[0];
else
dest[0]=!bv_utils.is_zero(src);
return false;
default:
if(dest_type.id()==ID_array)
{
if(src_width==dest_width)
{
dest=src;
return false;
}
}
else if(dest_type.id()==ID_struct)
{
const struct_typet &dest_struct =
to_struct_type(dest_type);
if(src_type.id()==ID_struct)
{
// we do subsets
dest.resize(dest_width, const_literal(false));
const struct_typet &op_struct =
to_struct_type(src_type);
const struct_typet::componentst &dest_comp=
dest_struct.components();
const struct_typet::componentst &op_comp=
op_struct.components();
// build offset maps
offset_mapt op_offsets, dest_offsets;
build_offset_map(op_struct, op_offsets);
build_offset_map(dest_struct, dest_offsets);
// build name map
typedef std::map<irep_idt, unsigned> op_mapt;
op_mapt op_map;
for(std::size_t i=0; i<op_comp.size(); i++)
op_map[op_comp[i].get_name()]=i;
// now gather required fields
for(std::size_t i=0;
i<dest_comp.size();
i++)
{
std::size_t offset=dest_offsets[i];
std::size_t comp_width=boolbv_width(dest_comp[i].type());
if(comp_width==0) continue;
op_mapt::const_iterator it=
op_map.find(dest_comp[i].get_name());
if(it==op_map.end())
{
// not found
// filling with free variables
for(std::size_t j=0; j<comp_width; j++)
dest[offset+j]=prop.new_variable();
}
else
{
// found
if(dest_comp[i].type()!=dest_comp[it->second].type())
{
// filling with free variables
for(std::size_t j=0; j<comp_width; j++)
dest[offset+j]=prop.new_variable();
}
else
{
std::size_t op_offset=op_offsets[it->second];
for(std::size_t j=0; j<comp_width; j++)
dest[offset+j]=src[op_offset+j];
}
}
}
return false;
}
}
}
return true;
}
void boolbvt::convert_unary_minus(const exprt &expr, bvt &bv)
{
const typet &type=ns.follow(expr.type());
unsigned width=boolbv_width(type);
if(width==0)
return conversion_failed(expr, bv);
const exprt::operandst &operands=expr.operands();
if(operands.size()!=1)
throw "unary minus takes one operand";
const exprt &op0=expr.op0();
const bvt &op_bv=convert_bv(op0);
bvtypet bvtype=get_bvtype(type);
bvtypet op_bvtype=get_bvtype(op0.type());
unsigned op_width=op_bv.size();
bool no_overflow=(expr.id()=="no-overflow-unary-minus");
if(op_width==0 || op_width!=width)
return conversion_failed(expr, bv);
if(bvtype==IS_UNKNOWN &&
(type.id()==ID_vector || type.id()==ID_complex))
{
const typet &subtype=ns.follow(type.subtype());
unsigned sub_width=boolbv_width(subtype);
if(sub_width==0 || width%sub_width!=0)
throw "unary-: unexpected vector operand width";
unsigned size=width/sub_width;
bv.resize(width);
for(unsigned i=0; i<size; i++)
{
bvt tmp_op;
tmp_op.resize(sub_width);
for(unsigned j=0; j<tmp_op.size(); j++)
{
assert(i*sub_width+j<op_bv.size());
tmp_op[j]=op_bv[i*sub_width+j];
}
bvt tmp_result;
if(type.subtype().id()==ID_floatbv)
{
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(subtype);
tmp_result=float_utils.negate(tmp_op);
}
else
tmp_result=bv_utils.negate(tmp_op);
assert(tmp_result.size()==sub_width);
for(unsigned j=0; j<tmp_result.size(); j++)
{
assert(i*sub_width+j<bv.size());
bv[i*sub_width+j]=tmp_result[j];
}
}
return;
}
else if(bvtype==IS_FIXED && op_bvtype==IS_FIXED)
{
if(no_overflow)
bv=bv_utils.negate_no_overflow(op_bv);
else
bv=bv_utils.negate(op_bv);
return;
}
else if(bvtype==IS_FLOAT && op_bvtype==IS_FLOAT)
{
assert(!no_overflow);
float_utilst float_utils(prop);
float_utils.spec=to_floatbv_type(expr.type());
bv=float_utils.negate(op_bv);
return;
}
else if((op_bvtype==IS_SIGNED || op_bvtype==IS_UNSIGNED) &&
(bvtype==IS_SIGNED || bvtype==IS_UNSIGNED))
{
if(no_overflow)
prop.l_set_to(bv_utils.overflow_negate(op_bv), false);
if(no_overflow)
bv=bv_utils.negate_no_overflow(op_bv);
else
bv=bv_utils.negate(op_bv);
return;
}
conversion_failed(expr, bv);
}
void boolbvt::convert_floatbv_op(const exprt &expr, bvt &bv)
{
const exprt::operandst &operands=expr.operands();
if(operands.size()!=3)
throw "operator "+expr.id_string()+" takes three operands";
const exprt &op0=expr.op0(); // first operand
const exprt &op1=expr.op1(); // second operand
const exprt &op2=expr.op2(); // rounding mode
bvt bv0=convert_bv(op0);
bvt bv1=convert_bv(op1);
bvt bv2=convert_bv(op2);
const typet &type=ns.follow(expr.type());
if(op0.type()!=type || op1.type()!=type)
{
std::cerr << expr.pretty() << std::endl;
throw "float op with mixed types";
}
float_utilst float_utils(prop);
float_utils.set_rounding_mode(bv2);
if(type.id()==ID_floatbv)
{
float_utils.spec=to_floatbv_type(expr.type());
if(expr.id()==ID_floatbv_plus)
bv=float_utils.add_sub(bv0, bv1, false);
else if(expr.id()==ID_floatbv_minus)
bv=float_utils.add_sub(bv0, bv1, true);
else if(expr.id()==ID_floatbv_mult)
bv=float_utils.mul(bv0, bv1);
else if(expr.id()==ID_floatbv_div)
bv=float_utils.div(bv0, bv1);
else if(expr.id()==ID_floatbv_rem)
bv=float_utils.rem(bv0, bv1);
else
assert(false);
}
else if(type.id()==ID_vector || type.id()==ID_complex)
{
const typet &subtype=ns.follow(type.subtype());
if(subtype.id()==ID_floatbv)
{
float_utils.spec=to_floatbv_type(subtype);
std::size_t width=boolbv_width(type);
std::size_t sub_width=boolbv_width(subtype);
if(sub_width==0 || width%sub_width!=0)
throw "convert_floatbv_op: unexpected vector operand width";
std::size_t size=width/sub_width;
bv.resize(width);
for(std::size_t i=0; i<size; i++)
{
bvt tmp_bv0, tmp_bv1, tmp_bv;
tmp_bv0.assign(bv0.begin()+i*sub_width, bv0.begin()+(i+1)*sub_width);
tmp_bv1.assign(bv1.begin()+i*sub_width, bv1.begin()+(i+1)*sub_width);
if(expr.id()==ID_floatbv_plus)
tmp_bv=float_utils.add_sub(tmp_bv0, tmp_bv1, false);
else if(expr.id()==ID_floatbv_minus)
tmp_bv=float_utils.add_sub(tmp_bv0, tmp_bv1, true);
else if(expr.id()==ID_floatbv_mult)
tmp_bv=float_utils.mul(tmp_bv0, tmp_bv1);
else if(expr.id()==ID_floatbv_div)
tmp_bv=float_utils.div(tmp_bv0, tmp_bv1);
else
assert(false);
assert(tmp_bv.size()==sub_width);
assert(i*sub_width+sub_width-1<bv.size());
std::copy(tmp_bv.begin(), tmp_bv.end(), bv.begin()+i*sub_width);
}
}
else
return conversion_failed(expr, bv);
}
else
return conversion_failed(expr, bv);
}
void boolbvt::convert_bitwise(const exprt &expr, bvt &bv)
{
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
if(expr.id()==ID_bitnot)
{
if(expr.operands().size()!=1)
throw "bitnot takes one operand";
const exprt &op0=expr.op0();
const bvt &op_bv=convert_bv(op0);
if(op_bv.size()!=width)
throw "convert_bitwise: unexpected operand width";
bv=bv_utils.inverted(op_bv);
return;
}
else if(expr.id()==ID_bitand || expr.id()==ID_bitor ||
expr.id()==ID_bitxor ||
expr.id()==ID_bitnand || expr.id()==ID_bitnor ||
expr.id()==ID_bitxnor)
{
bv.resize(width);
forall_operands(it, expr)
{
const bvt &op=convert_bv(*it);
if(op.size()!=width)
throw "convert_bitwise: unexpected operand width";
if(it==expr.operands().begin())
bv=op;
else
{
for(unsigned i=0; i<width; i++)
{
if(expr.id()==ID_bitand)
bv[i]=prop.land(bv[i], op[i]);
else if(expr.id()==ID_bitor)
bv[i]=prop.lor(bv[i], op[i]);
else if(expr.id()==ID_bitxor)
bv[i]=prop.lxor(bv[i], op[i]);
else if(expr.id()==ID_bitnand)
bv[i]=prop.lnand(bv[i], op[i]);
else if(expr.id()==ID_bitnor)
bv[i]=prop.lnor(bv[i], op[i]);
else if(expr.id()==ID_bitxnor)
bv[i]=prop.lequal(bv[i], op[i]);
else
throw "unexpected operand";
}
}
}
return;
}
void boolbvt::convert_member(const member_exprt &expr, bvt &bv)
{
const exprt &struct_op=expr.struct_op();
const typet &struct_op_type=ns.follow(struct_op.type());
const bvt &struct_bv=convert_bv(struct_op);
if(struct_op_type.id()==ID_union)
{
bv=convert_bv(
byte_extract_exprt(byte_extract_id(),
struct_op,
gen_zero(integer_typet()),
expr.type()));
return;
}
else if(struct_op_type.id()==ID_struct)
{
const irep_idt &component_name=expr.get_component_name();
const struct_typet::componentst &components=
to_struct_type(struct_op_type).components();
unsigned offset=0;
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++)
{
const typet &subtype=it->type();
unsigned sub_width=boolbv_width(subtype);
if(it->get_name()==component_name)
{
if(!base_type_eq(subtype, expr.type(), ns))
{
#if 0
std::cout << "DEBUG " << expr.pretty() << "\n";
#endif
throw "member: component type does not match: "+
subtype.to_string()+" vs. "+
expr.type().to_string();
}
bv.resize(sub_width);
assert(offset+sub_width<=struct_bv.size());
for(unsigned i=0; i<sub_width; i++)
bv[i]=struct_bv[offset+i];
return;
}
offset+=sub_width;
}
throw "component "+id2string(component_name)+" not found in structure";
}
else
throw "member takes struct or union operand";
}
void boolbvt::convert_case(const exprt &expr, bvt &bv)
{
const std::vector<exprt> &operands=expr.operands();
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
bv.resize(width);
// make it free variables
Forall_literals(it, bv)
*it=prop.new_variable();
if(operands.size()<3)
throw "case takes at least three operands";
if((operands.size()%2)!=1)
throw "number of case operands must be odd";
enum { FIRST, COMPARE, VALUE } what=FIRST;
bvt compare_bv;
literalt previous_compare=const_literal(false);
literalt compare_literal=const_literal(false);
forall_operands(it, expr)
{
bvt op=convert_bv(*it);
switch(what)
{
case FIRST:
compare_bv.swap(op);
what=COMPARE;
break;
case COMPARE:
if(compare_bv.size()!=op.size())
{
std::cerr << "compare operand: " << compare_bv.size()
<< std::endl
<< "operand: " << op.size() << std::endl
<< it->pretty()
<< std::endl;
throw "size of compare operand does not match";
}
compare_literal=bv_utils.equal(compare_bv, op);
compare_literal=prop.land(prop.lnot(previous_compare),
compare_literal);
previous_compare=prop.lor(previous_compare, compare_literal);
what=VALUE;
break;
case VALUE:
if(bv.size()!=op.size())
{
std::cerr << "result size: " << bv.size()
<< std::endl
<< "operand: " << op.size() << std::endl
<< it->pretty()
<< std::endl;
throw "size of value operand does not match";
}
{
literalt value_literal=bv_utils.equal(bv, op);
prop.l_set_to_true(
prop.limplies(compare_literal, value_literal));
}
what=COMPARE;
break;
default:
assert(false);
}
}
void boolbvt::convert_index(const index_exprt &expr, bvt &bv)
{
if(expr.id()!=ID_index)
throw "expected index expression";
if(expr.operands().size()!=2)
throw "index takes two operands";
const exprt &array=expr.array();
const exprt &index=expr.index();
const array_typet &array_type=
to_array_type(ns.follow(array.type()));
// see if the array size is constant
if(is_unbounded_array(array_type))
{
// use array decision procedure
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
// free variables
bv.resize(width);
for(unsigned i=0; i<width; i++)
bv[i]=prop.new_variable();
record_array_index(expr);
// record type if array is a symbol
if(array.id()==ID_symbol)
map.get_map_entry(
to_symbol_expr(array).get_identifier(), array_type);
// make sure we have the index in the cache
convert_bv(index);
return;
}
// see if the index address is constant
mp_integer index_value;
if(!to_integer(index, index_value))
return convert_index(array, index_value, bv);
unsigned width=boolbv_width(expr.type());
if(width==0)
return conversion_failed(expr, bv);
mp_integer array_size;
if(to_integer(array_type.size(), array_size))
{
std::cout << to_array_type(array.type()).size().pretty() << std::endl;
throw "failed to convert array size";
}
// get literals for the whole array
const bvt &array_bv=convert_bv(array);
if(array_size*width!=array_bv.size())
throw "unexpected array size";
// TODO: maybe a shifter-like construction would be better
if(prop.has_set_to())
{
// free variables
bv.resize(width);
for(unsigned i=0; i<width; i++)
bv[i]=prop.new_variable();
// add implications
equal_exprt index_equality;
index_equality.lhs()=index; // index operand
bvt equal_bv;
equal_bv.resize(width);
for(mp_integer i=0; i<array_size; i=i+1)
{
index_equality.rhs()=from_integer(i, index_equality.lhs().type());
if(index_equality.rhs().is_nil())
throw "number conversion failed (1)";
mp_integer offset=i*width;
for(unsigned j=0; j<width; j++)
equal_bv[j]=prop.lequal(bv[j],
array_bv[integer2long(offset+j)]);
prop.l_set_to_true(
prop.limplies(convert(index_equality), prop.land(equal_bv)));
}
}
else
{
bv.resize(width);
equal_exprt equality;
equality.lhs()=index; // index operand
typet constant_type=index.type(); // type of index operand
assert(array_size>0);
for(mp_integer i=0; i<array_size; i=i+1)
{
equality.op1()=from_integer(i, constant_type);
literalt e=convert(equality);
mp_integer offset=i*width;
for(unsigned j=0; j<width; j++)
{
literalt l=array_bv[integer2long(offset+j)];
if(i==0) // this initializes bv
bv[j]=l;
else
bv[j]=prop.lselect(e, l, bv[j]);
}
}
}
}