void boolbvt::convert_with_bv( const typet &type, const exprt &op1, const exprt &op2, const bvt &prev_bv, bvt &next_bv) { literalt l=convert(op2); mp_integer op1_value; if(!to_integer(op1, op1_value)) { next_bv=prev_bv; if(op1_value<next_bv.size()) next_bv[integer2size_t(op1_value)]=l; return; } typet counter_type=op1.type(); for(std::size_t i=0; i<prev_bv.size(); i++) { exprt counter=from_integer(i, counter_type); literalt eq_lit=convert(equal_exprt(op1, counter)); next_bv[i]=prop.lselect(eq_lit, l, prev_bv[i]); } }
exprt path_symex_statet::array_theory(const exprt &src, bool propagate) { // top-level constant-sized arrays only right now if(src.id()==ID_index) { const index_exprt &index_expr=to_index_expr(src); exprt index_tmp1=read(index_expr.index(), propagate); exprt index_tmp2=simplify_expr(index_tmp1, var_map.ns); if(!index_tmp2.is_constant()) { const array_typet &array_type=to_array_type(index_expr.array().type()); const typet &subtype=array_type.subtype(); if(array_type.size().is_constant()) { mp_integer size; if(to_integer(array_type.size(), size)) throw "failed to convert array size"; std::size_t size_int=integer2size_t(size); exprt result=nil_exprt(); // split it up for(std::size_t i=0; i<size_int; ++i) { exprt index=from_integer(i, index_expr.index().type()); exprt new_src=index_exprt(index_expr.array(), index, subtype); if(result.is_nil()) result=new_src; else { equal_exprt index_equal(index_expr.index(), index); result=if_exprt(index_equal, new_src, result); } } return result; // done } else { // TODO: variable-sized array } } } return src; }
void interpretert::read( mp_integer address, std::vector<mp_integer> &dest) const { // copy memory region for(auto &d : dest) { mp_integer value; if(address<memory.size()) value=memory[integer2size_t(address)].value; else value=0; d=value; ++address; } }
bvt float_utilst::rounder(const unbiased_floatt &src) { // incoming: some fraction (with explicit 1), // some exponent without bias // outgoing: rounded, with right size, with hidden bit, bias bvt aligned_fraction=src.fraction, aligned_exponent=src.exponent; { std::size_t exponent_bits= std::max((std::size_t)integer2size_t(address_bits(spec.f)), (std::size_t)spec.e)+1; // before normalization, make sure exponent is large enough if(aligned_exponent.size()<exponent_bits) { // sign extend aligned_exponent= bv_utils.sign_extension(aligned_exponent, exponent_bits); } } // align it! normalization_shift(aligned_fraction, aligned_exponent); denormalization_shift(aligned_fraction, aligned_exponent); unbiased_floatt result; result.fraction=aligned_fraction; result.exponent=aligned_exponent; result.sign=src.sign; result.NaN=src.NaN; result.infinity=src.infinity; round_fraction(result); round_exponent(result); return pack(bias(result)); }
void c_typecheck_baset::do_designated_initializer( exprt &result, designatort &designator, const exprt &value, bool force_constant) { assert(!designator.empty()); if(value.id()==ID_designated_initializer) { assert(value.operands().size()==1); designator= make_designator( designator.front().type, static_cast<const exprt &>(value.find(ID_designator))); assert(!designator.empty()); return do_designated_initializer( result, designator, value.op0(), force_constant); } exprt *dest=&result; // first phase: follow given designator for(size_t i=0; i<designator.size(); i++) { size_t index=designator[i].index; const typet &type=designator[i].type; const typet &full_type=follow(type); if(full_type.id()==ID_array || full_type.id()==ID_vector) { if(index>=dest->operands().size()) { if(full_type.id()==ID_array && (to_array_type(full_type).size().is_zero() || to_array_type(full_type).size().is_nil())) { // we are willing to grow an incomplete or zero-sized array exprt zero= zero_initializer( full_type.subtype(), value.source_location(), *this, get_message_handler()); dest->operands().resize(integer2size_t(index)+1, zero); // todo: adjust type! } else { err_location(value); error() << "array index designator " << index << " out of bounds (" << dest->operands().size() << ")" << eom; throw 0; } } dest=&(dest->operands()[integer2size_t(index)]); } else if(full_type.id()==ID_struct) { const struct_typet::componentst &components= to_struct_type(full_type).components(); if(index>=dest->operands().size()) { err_location(value); error() << "structure member designator " << index << " out of bounds (" << dest->operands().size() << ")" << eom; throw 0; } assert(index<components.size()); assert(components[index].type().id()!=ID_code && !components[index].get_is_padding()); dest=&(dest->operands()[index]); } else if(full_type.id()==ID_union) { const union_typet &union_type=to_union_type(full_type); const union_typet::componentst &components= union_type.components(); assert(index<components.size()); const union_typet::componentt &component=union_type.components()[index]; if(dest->id()==ID_union && dest->get(ID_component_name)==component.get_name()) { // Already right union component. We can initialize multiple submembers, // so do not overwrite this. } else { // Note that gcc issues a warning if the union component is switched. // Build a union expression from given component. union_exprt union_expr(type); union_expr.op()= zero_initializer( component.type(), value.source_location(), *this, get_message_handler()); union_expr.add_source_location()=value.source_location(); union_expr.set_component_name(component.get_name()); *dest=union_expr; } dest=&(dest->op0()); } else assert(false); } // second phase: assign value // for this, we may need to go down, adding to the designator while(true) { // see what type we have to initialize const typet &type=designator.back().subtype; const typet &full_type=follow(type); assert(full_type.id()!=ID_symbol); // do we initialize a scalar? if(full_type.id()!=ID_struct && full_type.id()!=ID_union && full_type.id()!=ID_array && full_type.id()!=ID_vector) { // The initializer for a scalar shall be a single expression, // * optionally enclosed in braces. * if(value.id()==ID_initializer_list && value.operands().size()==1) *dest=do_initializer_rec(value.op0(), type, force_constant); else *dest=do_initializer_rec(value, type, force_constant); assert(full_type==follow(dest->type())); return; // done } // union? The component in the zero initializer might // not be the first one. if(full_type.id()==ID_union) { const union_typet &union_type=to_union_type(full_type); const union_typet::componentst &components= union_type.components(); if(!components.empty()) { const union_typet::componentt &component= union_type.components().front(); union_exprt union_expr(type); union_expr.op()= zero_initializer( component.type(), value.source_location(), *this, get_message_handler()); union_expr.add_source_location()=value.source_location(); union_expr.set_component_name(component.get_name()); *dest=union_expr; } } // see what initializer we are given if(value.id()==ID_initializer_list) { *dest=do_initializer_rec(value, type, force_constant); return; // done } else if(value.id()==ID_string_constant) { // We stop for initializers that are string-constants, // which are like arrays. We only do so if we are to // initialize an array of scalars. if(full_type.id()==ID_array && (follow(full_type.subtype()).id()==ID_signedbv || follow(full_type.subtype()).id()==ID_unsignedbv)) { *dest=do_initializer_rec(value, type, force_constant); return; // done } } else if(follow(value.type())==full_type) { // a struct/union/vector can be initialized directly with // an expression of the right type. This doesn't // work with arrays, unfortunately. if(full_type.id()==ID_struct || full_type.id()==ID_union || full_type.id()==ID_vector) { *dest=value; return; // done } } assert(full_type.id()==ID_struct || full_type.id()==ID_union || full_type.id()==ID_array || full_type.id()==ID_vector); // we are initializing a compound type, and enter it! // this may change the type, full_type might not be valid anymore const typet dest_type=full_type; designator_enter(type, designator); if(dest->operands().empty()) { err_location(value); error() << "cannot initialize type `" << to_string(dest_type) << "' using value `" << to_string(value) << "'" << eom; throw 0; } dest=&(dest->op0()); // we run into another loop iteration } }
void c_typecheck_baset::designator_enter( const typet &type, designatort &designator) { designatort::entryt entry; entry.type=type; entry.index=0; const typet &full_type=follow(type); if(full_type.id()==ID_struct) { const struct_typet &struct_type=to_struct_type(full_type); entry.size=struct_type.components().size(); entry.subtype.make_nil(); for(struct_typet::componentst::const_iterator it=struct_type.components().begin(); it!=struct_type.components().end(); ++it) { if(it->type().id()!=ID_code && !it->get_is_padding()) { entry.subtype=it->type(); break; } ++entry.index; } } else if(full_type.id()==ID_union) { const union_typet &union_type=to_union_type(full_type); if(union_type.components().empty()) { entry.size=0; entry.subtype.make_nil(); } else { // The default is to unitialize using the first member of the // union. entry.size=1; entry.subtype=union_type.components().front().type(); } } else if(full_type.id()==ID_array) { const array_typet &array_type=to_array_type(full_type); if(array_type.size().is_nil()) { entry.size=0; entry.subtype=array_type.subtype(); } else { mp_integer array_size; if(to_integer(array_type.size(), array_size)) { err_location(array_type.size()); error() << "array has non-constant size `" << to_string(array_type.size()) << "'" << eom; throw 0; } entry.size=integer2size_t(array_size); entry.subtype=array_type.subtype(); } } else if(full_type.id()==ID_vector) { const vector_typet &vector_type=to_vector_type(full_type); mp_integer vector_size; if(to_integer(vector_type.size(), vector_size)) { err_location(vector_type.size()); error() << "vector has non-constant size `" << to_string(vector_type.size()) << "'" << eom; throw 0; } entry.size=integer2size_t(vector_size); entry.subtype=vector_type.subtype(); } else assert(false); designator.push_entry(entry); }
exprt boolbvt::bv_get_unbounded_array(const exprt &expr) const { // first, try to get size const typet &type=expr.type(); const exprt &size_expr=to_array_type(type).size(); exprt size=simplify_expr(get(size_expr), ns); // no size, give up if(size.is_nil()) return nil_exprt(); // get the numeric value, unless it's infinity mp_integer size_mpint; if(size.id()!=ID_infinity) { if(to_integer(size, size_mpint)) return nil_exprt(); // simple sanity check if(size_mpint<0) return nil_exprt(); } else size_mpint=0; // search array indices typedef std::map<mp_integer, exprt> valuest; valuest values; { std::size_t number; if(arrays.get_number(expr, number)) return nil_exprt(); // get root number=arrays.find_number(number); assert(number<index_map.size()); index_mapt::const_iterator it=index_map.find(number); assert(it!=index_map.end()); const index_sett &index_set=it->second; for(index_sett::const_iterator it1= index_set.begin(); it1!=index_set.end(); it1++) { index_exprt index; index.type()=type.subtype(); index.array()=expr; index.index()=*it1; exprt value=bv_get_cache(index); exprt index_value=bv_get_cache(*it1); if(!index_value.is_nil()) { mp_integer index_mpint; if(!to_integer(index_value, index_mpint)) { if(value.is_nil()) values[index_mpint]=exprt(ID_unknown, type.subtype()); else values[index_mpint]=value; } } } } exprt result; if(size_mpint>100 || size.id()==ID_infinity) { result=exprt("array-list", type); result.type().set(ID_size, integer2string(size_mpint)); result.operands().reserve(values.size()*2); for(valuest::const_iterator it=values.begin(); it!=values.end(); it++) { exprt index=from_integer(it->first, size.type()); result.copy_to_operands(index, it->second); } } else { // set the size result=exprt(ID_array, type); result.type().set(ID_size, size); std::size_t size_int=integer2size_t(size_mpint); // allocate operands result.operands().resize(size_int); for(std::size_t i=0; i<size_int; i++) result.operands()[i]=exprt(ID_unknown); // search uninterpreted functions for(valuest::iterator it=values.begin(); it!=values.end(); it++) if(it->first>=0 && it->first<size_mpint) result.operands()[integer2size_t(it->first)].swap(it->second); } return result; }
bvt boolbvt::convert_byte_update(const byte_update_exprt &expr) { if(expr.operands().size()!=3) throw "byte_update takes three operands"; const exprt &op=expr.op0(); const exprt &offset_expr=expr.offset(); const exprt &value=expr.value(); bool little_endian; if(expr.id()==ID_byte_update_little_endian) little_endian=true; else if(expr.id()==ID_byte_update_big_endian) little_endian=false; else assert(false); bvt bv=convert_bv(op); const bvt &value_bv=convert_bv(value); std::size_t update_width=value_bv.size(); std::size_t byte_width=8; if(update_width>bv.size()) update_width=bv.size(); // see if the byte number is constant mp_integer index; if(!to_integer(offset_expr, index)) { // yes! mp_integer offset=index*8; if(offset+update_width>mp_integer(bv.size()) || offset<0) { // out of bounds } else { if(little_endian) { for(std::size_t i=0; i<update_width; i++) bv[integer2size_t(offset+i)]=value_bv[i]; } else { endianness_mapt map_op(op.type(), false, ns); endianness_mapt map_value(value.type(), false, ns); std::size_t offset_i=integer2unsigned(offset); for(std::size_t i=0; i<update_width; i++) { size_t index_op=map_op.map_bit(offset_i+i); size_t index_value=map_value.map_bit(i); assert(index_op<bv.size()); assert(index_value<value_bv.size()); bv[index_op]=value_bv[index_value]; } } } return bv; } // byte_update with variable index for(std::size_t offset=0; offset<bv.size(); offset+=byte_width) { // index condition equal_exprt equality; equality.lhs()=offset_expr; equality.rhs()=from_integer(offset/byte_width, offset_expr.type()); literalt equal=convert(equality); endianness_mapt map_op(op.type(), little_endian, ns); endianness_mapt map_value(value.type(), little_endian, ns); for(std::size_t bit=0; bit<update_width; bit++) if(offset+bit<bv.size()) { std::size_t bv_o=map_op.map_bit(offset+bit); std::size_t value_bv_o=map_value.map_bit(bit); bv[bv_o]=prop.lselect(equal, value_bv[value_bv_o], bv[bv_o]); } } return bv; }
exprt path_symex_statet::expand_structs_and_arrays(const exprt &src) { #ifdef DEBUG std::cout << "expand_structs_and_arrays: " << from_expr(var_map.ns, "", src) << '\n'; #endif const typet &src_type=var_map.ns.follow(src.type()); if(src_type.id()==ID_struct) // src is a struct { const struct_typet &struct_type=to_struct_type(src_type); const struct_typet::componentst &components=struct_type.components(); struct_exprt result(src.type()); result.operands().resize(components.size()); // split it up into components for(unsigned i=0; i<components.size(); i++) { const typet &subtype=components[i].type(); const irep_idt &component_name=components[i].get_name(); exprt new_src; if(src.id()==ID_struct) // struct constructor? { assert(src.operands().size()==components.size()); new_src=src.operands()[i]; } else new_src=member_exprt(src, component_name, subtype); // recursive call result.operands()[i]=expand_structs_and_arrays(new_src); } return result; // done } else if(src_type.id()==ID_array) // src is an array { const array_typet &array_type=to_array_type(src_type); const typet &subtype=array_type.subtype(); if(array_type.size().is_constant()) { mp_integer size; if(to_integer(array_type.size(), size)) throw "failed to convert array size"; std::size_t size_int=integer2size_t(size); array_exprt result(array_type); result.operands().resize(size_int); // split it up into elements for(std::size_t i=0; i<size_int; ++i) { exprt index=from_integer(i, array_type.size().type()); exprt new_src=index_exprt(src, index, subtype); // array constructor? if(src.id()==ID_array) new_src=simplify_expr(new_src, var_map.ns); // recursive call result.operands()[i]=expand_structs_and_arrays(new_src); } return result; // done } else { // TODO: variable-sized array } } else if(src_type.id()==ID_vector) // src is a vector { const vector_typet &vector_type=to_vector_type(src_type); const typet &subtype=vector_type.subtype(); if(!vector_type.size().is_constant()) throw "vector with non-constant size"; mp_integer size; if(to_integer(vector_type.size(), size)) throw "failed to convert vector size"; std::size_t size_int=integer2size_t(size); vector_exprt result(vector_type); exprt::operandst &operands=result.operands(); operands.resize(size_int); // split it up into elements for(std::size_t i=0; i<size_int; ++i) { exprt index=from_integer(i, vector_type.size().type()); exprt new_src=index_exprt(src, index, subtype); // vector constructor? if(src.id()==ID_vector) new_src=simplify_expr(new_src, var_map.ns); // recursive call operands[i]=expand_structs_and_arrays(new_src); } return result; // done } return src; }
bool simplify_exprt::simplify_index(exprt &expr) { bool result=true; // extra arithmetic optimizations const exprt &index=to_index_expr(expr).index(); const exprt &array=to_index_expr(expr).array(); if(index.id()==ID_div && index.operands().size()==2) { if(index.op0().id()==ID_mult && index.op0().operands().size()==2 && index.op0().op1()==index.op1()) { exprt tmp=index.op0().op0(); expr.op1()=tmp; result=false; } else if(index.op0().id()==ID_mult && index.op0().operands().size()==2 && index.op0().op0()==index.op1()) { exprt tmp=index.op0().op1(); expr.op1()=tmp; result=false; } } if(array.id()==ID_lambda) { // simplify (lambda i: e)(x) to e[i/x] const exprt &lambda_expr=array; if(lambda_expr.operands().size()!=2) return true; if(expr.op1().type()==lambda_expr.op0().type()) { exprt tmp=lambda_expr.op1(); replace_expr(lambda_expr.op0(), expr.op1(), tmp); expr.swap(tmp); return false; } } else if(array.id()==ID_with) { // we have (a WITH [i:=e])[j] const exprt &with_expr=array; if(with_expr.operands().size()!=3) return true; if(with_expr.op1()==expr.op1()) { // simplify (e with [i:=v])[i] to v exprt tmp=with_expr.op2(); expr.swap(tmp); return false; } else { // Turn (a with i:=x)[j] into (i==j)?x:a[j]. // watch out that the type of i and j might be different. equal_exprt equality_expr(expr.op1(), with_expr.op1()); if(equality_expr.lhs().type()!=equality_expr.rhs().type()) equality_expr.rhs().make_typecast(equality_expr.lhs().type()); simplify_inequality(equality_expr); index_exprt new_index_expr; new_index_expr.type()=expr.type(); new_index_expr.array()=with_expr.op0(); new_index_expr.index()=expr.op1(); simplify_index(new_index_expr); // recursive call if(equality_expr.is_true()) { expr=with_expr.op2(); return false; } else if(equality_expr.is_false()) { expr.swap(new_index_expr); return false; } if_exprt if_expr(equality_expr, with_expr.op2(), new_index_expr); simplify_if(if_expr); expr.swap(if_expr); return false; } } else if(array.id()==ID_constant || array.id()==ID_array) { mp_integer i; if(to_integer(expr.op1(), i)) { } else if(i<0 || i>=array.operands().size()) { // out of bounds } else { // ok exprt tmp=array.operands()[integer2size_t(i)]; expr.swap(tmp); return false; } } else if(array.id()==ID_string_constant) { mp_integer i; const irep_idt &value=array.get(ID_value); if(to_integer(expr.op1(), i)) { } else if(i<0 || i>value.size()) { // out of bounds } else { // terminating zero? char v=(i==value.size())?0:value[integer2size_t(i)]; exprt tmp=from_integer(v, expr.type()); expr.swap(tmp); return false; } } else if(array.id()==ID_array_of) { if(array.operands().size()==1) { exprt tmp=array.op0(); expr.swap(tmp); return false; } } else if(array.id()=="array-list") { // These are index/value pairs, alternating. for(size_t i=0; i<array.operands().size()/2; i++) { exprt tmp_index=array.operands()[i*2]; tmp_index.make_typecast(index.type()); simplify(tmp_index); if(tmp_index==index) { exprt tmp=array.operands()[i*2+1]; expr.swap(tmp); return false; } } } else if(array.id()==ID_byte_extract_little_endian || array.id()==ID_byte_extract_big_endian) { const typet &array_type=ns.follow(array.type()); if(array_type.id()==ID_array) { // This rewrites byte_extract(s, o, array_type)[i] // to byte_extract(s, o+offset, sub_type) mp_integer sub_size=pointer_offset_size(array_type.subtype(), ns); if(sub_size==-1) return true; // add offset to index mult_exprt offset(from_integer(sub_size, array.op1().type()), index); plus_exprt final_offset(array.op1(), offset); simplify_node(final_offset); exprt result(array.id(), expr.type()); result.copy_to_operands(array.op0(), final_offset); expr.swap(result); simplify_rec(expr); return false; } } else if(array.id()==ID_if) { const if_exprt &if_expr=to_if_expr(array); exprt cond=if_expr.cond(); index_exprt idx_false=to_index_expr(expr); idx_false.array()=if_expr.false_case(); to_index_expr(expr).array()=if_expr.true_case(); expr=if_exprt(cond, expr, idx_false, expr.type()); simplify_rec(expr); return false; } return result; }
bool simplify_exprt::simplify_floatbv_typecast(exprt &expr) { // These casts usually reduce precision, and thus, usually round. assert(expr.operands().size()==2); const typet &dest_type=ns.follow(expr.type()); const typet &src_type=ns.follow(expr.op0().type()); // eliminate redundant casts if(dest_type==src_type) { expr=expr.op0(); return false; } exprt op0=expr.op0(); exprt op1=expr.op1(); // rounding mode // We can soundly re-write (float)((double)x op (double)y) // to x op y. True for any rounding mode! #if 0 if(op0.id()==ID_floatbv_div || op0.id()==ID_floatbv_mult || op0.id()==ID_floatbv_plus || op0.id()==ID_floatbv_minus) { if(op0.operands().size()==3 && op0.op0().id()==ID_typecast && op0.op1().id()==ID_typecast && op0.op0().operands().size()==1 && op0.op1().operands().size()==1 && ns.follow(op0.op0().type())==dest_type && ns.follow(op0.op1().type())==dest_type) { exprt result(op0.id(), expr.type()); result.operands().resize(3); result.op0()=op0.op0().op0(); result.op1()=op0.op1().op0(); result.op2()=op1; simplify_node(result); expr.swap(result); return false; } } #endif // constant folding if(op0.is_constant() && op1.is_constant()) { mp_integer rounding_mode; if(!to_integer(op1, rounding_mode)) { if(src_type.id()==ID_floatbv) { if(dest_type.id()==ID_floatbv) // float to float { ieee_floatt result(to_constant_expr(op0)); result.rounding_mode=(ieee_floatt::rounding_modet)integer2size_t(rounding_mode); result.change_spec(to_floatbv_type(dest_type)); expr=result.to_expr(); return false; } else if(dest_type.id()==ID_signedbv || dest_type.id()==ID_unsignedbv) { if(rounding_mode==ieee_floatt::ROUND_TO_ZERO) { ieee_floatt result(to_constant_expr(op0)); result.rounding_mode=(ieee_floatt::rounding_modet)integer2size_t(rounding_mode); mp_integer value=result.to_integer(); expr=from_integer(value, dest_type); return false; } } } else if(src_type.id()==ID_signedbv || src_type.id()==ID_unsignedbv) { mp_integer value; if(!to_integer(op0, value)) { if(dest_type.id()==ID_floatbv) // int to float { ieee_floatt result; result.rounding_mode=(ieee_floatt::rounding_modet)integer2size_t(rounding_mode); result.spec=to_floatbv_type(dest_type); result.from_integer(value); expr=result.to_expr(); return false; } } } } } #if 0 // (T)(a?b:c) --> a?(T)b:(T)c if(expr.op0().id()==ID_if && expr.op0().operands().size()==3) { exprt tmp_op1=binary_exprt(expr.op0().op1(), ID_floatbv_typecast, expr.op1(), dest_type); exprt tmp_op2=binary_exprt(expr.op0().op2(), ID_floatbv_typecast, expr.op1(), dest_type); simplify_floatbv_typecast(tmp_op1); simplify_floatbv_typecast(tmp_op2); expr=if_exprt(expr.op0().op0(), tmp_op1, tmp_op2, dest_type); simplify_if(expr); return false; } #endif return true; }
bvt boolbvt::convert_shift(const binary_exprt &expr) { const irep_idt &type_id=expr.type().id(); if(type_id!=ID_unsignedbv && type_id!=ID_signedbv && type_id!=ID_floatbv && type_id!=ID_pointer && type_id!=ID_bv && type_id!=ID_verilog_signedbv && type_id!=ID_verilog_unsignedbv) return conversion_failed(expr); std::size_t width=boolbv_width(expr.type()); if(width==0) return conversion_failed(expr); if(expr.operands().size()!=2) throw "shifting takes two operands"; const bvt &op=convert_bv(expr.op0()); if(op.size()!=width) throw "convert_shift: unexpected operand 0 width"; bv_utilst::shiftt shift; if(expr.id()==ID_shl) shift=bv_utilst::shiftt::LEFT; else if(expr.id()==ID_ashr) shift=bv_utilst::shiftt::ARIGHT; else if(expr.id()==ID_lshr) shift=bv_utilst::shiftt::LRIGHT; else throw "unexpected shift operator"; // we allow a constant as shift distance if(expr.op1().is_constant()) { mp_integer i; if(to_integer(expr.op1(), i)) throw "convert_shift: failed to convert constant"; std::size_t distance; if(i<0 || i>std::numeric_limits<signed>::max()) distance=0; else distance=integer2size_t(i); if(type_id==ID_verilog_signedbv || type_id==ID_verilog_unsignedbv) distance*=2; return bv_utils.shift(op, shift, distance); } else { const bvt &distance=convert_bv(expr.op1()); return bv_utils.shift(op, shift, distance); } }
std::string ieee_floatt::to_string_decimal(std::size_t precision) const { std::string result; if(sign_flag) result+='-'; if((NaN_flag || infinity_flag) && !sign_flag) result+='+'; // special cases if(NaN_flag) result+="NaN"; else if(infinity_flag) result+="inf"; else if(is_zero()) { result+='0'; // add zeros, if needed if(precision>0) { result+='.'; for(std::size_t i=0; i<precision; i++) result+='0'; } } else { mp_integer _exponent, _fraction; extract_base2(_fraction, _exponent); // convert to base 10 if(_exponent>=0) { result+=integer2string(_fraction*power(2, _exponent)); // add dot and zeros, if needed if(precision>0) { result+='.'; for(std::size_t i=0; i<precision; i++) result+='0'; } } else { #if 1 mp_integer position=-_exponent; // 10/2=5 -- this makes it base 10 _fraction*=power(5, position); // apply rounding if(position>precision) { mp_integer r=power(10, position-precision); mp_integer remainder=_fraction%r; _fraction/=r; // not sure if this is the right kind of rounding here if(remainder>=r/2) ++_fraction; position=precision; } std::string tmp=integer2string(_fraction); // pad with zeros from the front, if needed while(mp_integer(tmp.size())<=position) tmp="0"+tmp; std::size_t dot=tmp.size()-integer2size_t(position); result+=std::string(tmp, 0, dot)+'.'; result+=std::string(tmp, dot, std::string::npos); // append zeros if needed for(mp_integer i=position; i<precision; ++i) result+='0'; #else result+=integer2string(_fraction); if(_exponent!=0) result+="*2^"+integer2string(_exponent); #endif } } return result; }
void boolbvt::convert_update_rec( const exprt::operandst &designators, std::size_t d, const typet &type, std::size_t offset, const exprt &new_value, bvt &bv) { if(type.id()==ID_symbol) convert_update_rec( designators, d, ns.follow(type), offset, new_value, bv); if(d>=designators.size()) { // done bvt new_value_bv=convert_bv(new_value); std::size_t new_value_width=boolbv_width(type); if(new_value_width!=new_value_bv.size()) throw "convert_update_rec: unexpected new_value size"; // update for(std::size_t i=0; i<new_value_width; i++) { assert(offset+i<bv.size()); bv[offset+i]=new_value_bv[i]; } return; } const exprt &designator=designators[d]; if(designator.id()==ID_index_designator) { if(type.id()!=ID_array) throw "update: index designator needs array"; if(designator.operands().size()!=1) throw "update: index designator takes one operand"; bvt index_bv=convert_bv(designator.op0()); const array_typet &array_type=to_array_type(type); const typet &subtype=ns.follow(array_type.subtype()); std::size_t element_size=boolbv_width(subtype); // iterate over array mp_integer size; if(to_integer(array_type.size(), size)) throw "update: failed to get array size"; bvt tmp_bv=bv; for(std::size_t i=0; i!=integer2size_t(size); ++i) { std::size_t new_offset=offset+i*element_size; convert_update_rec( designators, d+1, subtype, new_offset, new_value, tmp_bv); bvt const_bv=bv_utils.build_constant(i, index_bv.size()); literalt equal=bv_utils.equal(const_bv, index_bv); for(std::size_t j=0; j<element_size; j++) { std::size_t idx=new_offset+j; assert(idx<bv.size()); bv[idx]=prop.lselect(equal, tmp_bv[idx], bv[idx]); } } } else if(designator.id()==ID_member_designator) { const irep_idt &component_name=designator.get(ID_component_name); if(type.id()==ID_struct) { const struct_typet &struct_type= to_struct_type(type); std::size_t struct_offset=0; struct_typet::componentt component; component.make_nil(); const struct_typet::componentst &components= struct_type.components(); for(struct_typet::componentst::const_iterator it=components.begin(); it!=components.end(); it++) { const typet &subtype=it->type(); std::size_t sub_width=boolbv_width(subtype); if(it->get_name()==component_name) { component=*it; break; // done } struct_offset+=sub_width; } if(component.is_nil()) throw "update: failed to find struct component"; const typet &new_type=ns.follow(component.type()); std::size_t new_offset=offset+struct_offset; // recursive call convert_update_rec( designators, d+1, new_type, new_offset, new_value, bv); } else if(type.id()==ID_union) { const union_typet &union_type= to_union_type(type); const union_typet::componentt &component= union_type.get_component(component_name); if(component.is_nil()) throw "update: failed to find union component"; // this only adjusts the type, the offset stays as-is const typet &new_type=ns.follow(component.type()); // recursive call convert_update_rec( designators, d+1, new_type, offset, new_value, bv); } else throw "update: member designator needs struct or union"; } else throw "update: unexpected designator"; }
designatort c_typecheck_baset::make_designator( const typet &src_type, const exprt &src) { assert(!src.operands().empty()); typet type=src_type; designatort designator; forall_operands(it, src) { const exprt &d_op=*it; designatort::entryt entry; entry.type=type; const typet &full_type=follow(entry.type); if(full_type.id()==ID_array) { if(d_op.id()!=ID_index) { err_location(d_op); error() << "expected array index designator" << eom; throw 0; } assert(d_op.operands().size()==1); exprt tmp_index=d_op.op0(); make_constant_index(tmp_index); mp_integer index, size; if(to_integer(tmp_index, index)) { err_location(d_op.op0()); error() << "expected constant array index designator" << eom; throw 0; } if(to_array_type(full_type).size().is_nil()) size=0; else if(to_integer(to_array_type(full_type).size(), size)) { err_location(d_op.op0()); error() << "expected constant array size" << eom; throw 0; } entry.index=integer2size_t(index); entry.size=integer2size_t(size); entry.subtype=full_type.subtype(); } else if(full_type.id()==ID_struct || full_type.id()==ID_union) { const struct_union_typet &struct_union_type= to_struct_union_type(full_type); if(d_op.id()!=ID_member) { err_location(d_op); error() << "expected member designator" << eom; throw 0; } const irep_idt &component_name=d_op.get(ID_component_name); if(struct_union_type.has_component(component_name)) { // a direct member entry.index=struct_union_type.component_number(component_name); entry.size=struct_union_type.components().size(); entry.subtype=struct_union_type.components()[entry.index].type(); } else { // We will search for anonymous members, // in a loop. This isn't supported by gcc, but icc does allow it. bool found=false, repeat; typet tmp_type=entry.type; do { repeat=false; unsigned number=0; const struct_union_typet::componentst &components= to_struct_union_type(follow(tmp_type)).components(); for(struct_union_typet::componentst::const_iterator c_it=components.begin(); c_it!=components.end(); c_it++, number++) { if(c_it->get_name()==component_name) { // done! entry.index=number; entry.size=components.size(); entry.subtype=components[entry.index].type(); entry.type=tmp_type; } else if(c_it->get_anonymous() && (follow(c_it->type()).id()==ID_struct || follow(c_it->type()).id()==ID_union) && has_component_rec( c_it->type(), component_name, *this)) { entry.index=number; entry.size=components.size(); entry.subtype=c_it->type(); entry.type=tmp_type; tmp_type=entry.subtype; designator.push_entry(entry); found=repeat=true; break; } } } while(repeat); if(!found) { err_location(d_op); error() << "failed to find struct component `" << component_name << "' in initialization of `" << to_string(struct_union_type) << "'" << eom; throw 0; } } } else { err_location(d_op); error() << "designated initializers cannot initialize `" << to_string(full_type) << "'" << eom; throw 0; } type=entry.subtype; designator.push_entry(entry); } assert(!designator.empty()); return designator; }
exprt c_typecheck_baset::do_initializer_rec( const exprt &value, const typet &type, bool force_constant) { const typet &full_type=follow(type); if(full_type.id()==ID_incomplete_struct) { err_location(value); error() << "type `" << to_string(full_type) << "' is still incomplete -- cannot initialize" << eom; throw 0; } if(value.id()==ID_initializer_list) return do_initializer_list(value, type, force_constant); if(value.id()==ID_array && value.get_bool(ID_C_string_constant) && full_type.id()==ID_array && (full_type.subtype().id()==ID_signedbv || full_type.subtype().id()==ID_unsignedbv) && full_type.subtype().get(ID_width)==value.type().subtype().get(ID_width)) { exprt tmp=value; // adjust char type tmp.type().subtype()=full_type.subtype(); Forall_operands(it, tmp) it->type()=full_type.subtype(); if(full_type.id()==ID_array && to_array_type(full_type).is_complete()) { // check size mp_integer array_size; if(to_integer(to_array_type(full_type).size(), array_size)) { err_location(value); error() << "array size needs to be constant, got " << to_string(to_array_type(full_type).size()) << eom; throw 0; } if(array_size<0) { err_location(value); error() << "array size must not be negative" << eom; throw 0; } if(mp_integer(tmp.operands().size())>array_size) { // cut off long strings. gcc does a warning for this tmp.operands().resize(integer2size_t(array_size)); tmp.type()=type; } else if(mp_integer(tmp.operands().size())<array_size) { // fill up tmp.type()=type; exprt zero= zero_initializer( full_type.subtype(), value.source_location(), *this, get_message_handler()); tmp.operands().resize(integer2size_t(array_size), zero); } } return tmp; } if(value.id()==ID_string_constant && full_type.id()==ID_array && (full_type.subtype().id()==ID_signedbv || full_type.subtype().id()==ID_unsignedbv) && full_type.subtype().get(ID_width)==char_type().get(ID_width)) { // will go away, to be replaced by the above block string_constantt tmp1=to_string_constant(value); // adjust char type tmp1.type().subtype()=full_type.subtype(); exprt tmp2=tmp1.to_array_expr(); if(full_type.id()==ID_array && to_array_type(full_type).is_complete()) { // check size mp_integer array_size; if(to_integer(to_array_type(full_type).size(), array_size)) { err_location(value); error() << "array size needs to be constant, got " << to_string(to_array_type(full_type).size()) << eom; throw 0; } if(array_size<0) { err_location(value); error() << "array size must not be negative" << eom; throw 0; } if(mp_integer(tmp2.operands().size())>array_size) { // cut off long strings. gcc does a warning for this tmp2.operands().resize(integer2size_t(array_size)); tmp2.type()=type; } else if(mp_integer(tmp2.operands().size())<array_size) { // fill up tmp2.type()=type; exprt zero= zero_initializer( full_type.subtype(), value.source_location(), *this, get_message_handler()); tmp2.operands().resize(integer2size_t(array_size), zero); } } return tmp2; } if(full_type.id()==ID_array && to_array_type(full_type).size().is_nil()) { err_location(value); error() << "type `" << to_string(full_type) << "' cannot be initialized with `" << to_string(value) << "'" << eom; throw 0; } if(value.id()==ID_designated_initializer) { err_location(value); error() << "type `" << to_string(full_type) << "' cannot be initialized with designated initializer" << eom; throw 0; } exprt result=value; implicit_typecast(result, type); return result; }
void c_typecheck_baset::typecheck_c_bit_field_type(c_bit_field_typet &type) { typecheck_type(type.subtype()); mp_integer i; { exprt &width_expr=static_cast<exprt &>(type.add(ID_size)); typecheck_expr(width_expr); make_constant_index(width_expr); if(to_integer(width_expr, i)) { error().source_location=type.source_location(); error() << "failed to convert bit field width" << eom; throw 0; } if(i<0) { error().source_location=type.source_location(); error() << "bit field width is negative" << eom; throw 0; } type.set_width(integer2size_t(i)); type.remove(ID_size); } const typet &subtype=follow(type.subtype()); std::size_t sub_width=0; if(subtype.id()==ID_bool) { // This is the 'proper' bool. sub_width=1; } else if(subtype.id()==ID_signedbv || subtype.id()==ID_unsignedbv || subtype.id()==ID_c_bool) { sub_width=to_bitvector_type(subtype).get_width(); } else if(subtype.id()==ID_c_enum_tag) { // These point to an enum, which has a sub-subtype, // which may be smaller or larger than int, and we thus have // to check. const typet &c_enum_type= follow_tag(to_c_enum_tag_type(subtype)); if(c_enum_type.id()==ID_incomplete_c_enum) { error().source_location=type.source_location(); error() << "bit field has incomplete enum type" << eom; throw 0; } sub_width=c_enum_type.subtype().get_int(ID_width); } else { error().source_location=type.source_location(); error() << "bit field with non-integer type: " << to_string(subtype) << eom; throw 0; } if(i>sub_width) { error().source_location=type.source_location(); error() << "bit field (" << i << " bits) larger than type (" << sub_width << " bits)" << eom; throw 0; } }
bool simplify_exprt::simplify_floatbv_op(exprt &expr) { const typet &type=ns.follow(expr.type()); if(type.id()!=ID_floatbv) return true; assert(expr.operands().size()==3); exprt op0=expr.op0(); exprt op1=expr.op1(); exprt op2=expr.op2(); // rounding mode assert(ns.follow(op0.type())==type); assert(ns.follow(op1.type())==type); // Remember that floating-point addition is _NOT_ associative. // Thus, we don't re-sort the operands. // We only merge constants! if(op0.is_constant() && op1.is_constant() && op2.is_constant()) { ieee_floatt v0(to_constant_expr(op0)); ieee_floatt v1(to_constant_expr(op1)); mp_integer rounding_mode; if(!to_integer(op2, rounding_mode)) { v0.rounding_mode=(ieee_floatt::rounding_modet)integer2size_t(rounding_mode); v1.rounding_mode=v0.rounding_mode; ieee_floatt result=v0; if(expr.id()==ID_floatbv_plus) result+=v1; else if(expr.id()==ID_floatbv_minus) result-=v1; else if(expr.id()==ID_floatbv_mult) result*=v1; else if(expr.id()==ID_floatbv_div) result/=v1; else assert(false); expr=result.to_expr(); return false; } } // division by one? Exact for all rounding modes. if (expr.id()==ID_floatbv_div && op1.is_constant() && op1.is_one()) { exprt tmp; tmp.swap(op0); expr.swap(tmp); return false; } return true; }
bool remove_const_function_pointerst::try_resolve_index_of( const index_exprt &index_expr, expressionst &out_expressions, bool &out_is_const) { // Get the array(s) it belongs to expressionst potential_array_exprs; bool array_const=false; bool resolved_array= try_resolve_expression( index_expr.array(), potential_array_exprs, array_const); if(resolved_array) { bool all_possible_const=true; for(const exprt &potential_array_expr : potential_array_exprs) { all_possible_const= all_possible_const && is_const_type(potential_array_expr.type().subtype()); if(potential_array_expr.id()==ID_array) { // Get the index if we can mp_integer value; if(try_resolve_index_value(index_expr.index(), value)) { expressionst array_out_functions; const exprt &func_expr= potential_array_expr.operands()[integer2size_t(value)]; bool value_const=false; bool resolved_value= try_resolve_expression(func_expr, array_out_functions, value_const); if(resolved_value) { out_expressions.insert( out_expressions.end(), array_out_functions.begin(), array_out_functions.end()); } else { LOG("Failed to resolve array value", func_expr); return false; } } else { // We don't know what index it is, // but we know the value is from the array for(const exprt &array_entry : potential_array_expr.operands()) { expressionst array_contents; bool is_entry_const; bool resolved_value= try_resolve_expression( array_entry, array_contents, is_entry_const); if(!resolved_value) { LOG("Failed to resolve array value", array_entry); return false; } for(const exprt &resolved_array_entry : array_contents) { if(!resolved_array_entry.is_zero()) { out_expressions.push_back(resolved_array_entry); } } } } } else { LOG( "Squashing index of did not result in an array", potential_array_expr); return false; } } out_is_const=all_possible_const || array_const; return true; } else { LOG("Failed to squash index of to array expression", index_expr); return false; } }