void polynomial_acceleratort::assert_for_values(scratch_programt &program, std::map<exprt, int> &values, std::set<std::pair<expr_listt, exprt> > &coefficients, int num_unwindings, goto_programt::instructionst &loop_body, exprt &target, overflow_instrumentert &overflow) { // First figure out what the appropriate type for this expression is. typet expr_type = nil_typet(); for (std::map<exprt, int>::iterator it = values.begin(); it != values.end(); ++it) { typet this_type=it->first.type(); if (this_type.id() == ID_pointer) { #ifdef DEBUG std::cout << "Overriding pointer type" << std::endl; #endif this_type = unsignedbv_typet(config.ansi_c.pointer_width); } if (expr_type == nil_typet()) { expr_type = this_type; } else { expr_type = join_types(expr_type, this_type); } } assert(to_bitvector_type(expr_type).get_width()>0); // Now set the initial values of the all the variables... for (std::map<exprt, int>::iterator it = values.begin(); it != values.end(); ++it) { program.assign(it->first, from_integer(it->second, expr_type)); } // Now unwind the loop as many times as we need to. for (int i = 0; i < num_unwindings; i++) { program.append(loop_body); } // Now build the polynomial for this point and assert it fits. exprt rhs = nil_exprt(); for (std::set<std::pair<expr_listt, exprt> >::iterator it = coefficients.begin(); it != coefficients.end(); ++it) { int concrete_value = 1; for (expr_listt::const_iterator e_it = it->first.begin(); e_it != it->first.end(); ++e_it) { exprt e = *e_it; if (e == loop_counter) { concrete_value *= num_unwindings; } else { std::map<exprt, int>::iterator v_it = values.find(e); if (v_it != values.end()) { concrete_value *= v_it->second; } } } // OK, concrete_value now contains the value of all the relevant variables // multiplied together. Create the term concrete_value*coefficient and add // it into the polynomial. typecast_exprt cast(it->second, expr_type); exprt term = mult_exprt(from_integer(concrete_value, expr_type), cast); if (rhs.is_nil()) { rhs = term; } else { rhs = plus_exprt(rhs, term); } } exprt overflow_expr; overflow.overflow_expr(rhs, overflow_expr); program.add_instruction(ASSUME)->guard = not_exprt(overflow_expr); rhs = typecast_exprt(rhs, target.type()); // We now have the RHS of the polynomial. Assert that this is equal to the // actual value of the variable we're fitting. exprt polynomial_holds = equal_exprt(target, rhs); // Finally, assert that the polynomial equals the variable we're fitting. goto_programt::targett assumption = program.add_instruction(ASSUME); assumption->guard = polynomial_holds; }
typet java_type_from_string(const std::string &src) { if(src.empty()) return nil_typet(); switch(src[0]) { case '(': // function type { std::size_t e_pos=src.rfind(')'); if(e_pos==std::string::npos) return nil_typet(); code_typet result; result.return_type()= java_type_from_string(std::string(src, e_pos+1, std::string::npos)); for(std::size_t i=1; i<src.size() && src[i]!=')'; i++) { code_typet::parametert param; size_t start=i; while(i<src.size()) { if(src[i]=='L') { i=src.find(';', i); // ends on ; break; } else if(src[i]=='[') i++; else break; } std::string sub_str=src.substr(start, i-start+1); param.type()=java_type_from_string(sub_str); if(param.type().id()==ID_symbol) param.type()=java_reference_type(param.type()); result.parameters().push_back(param); } return result; } case '[': // array type { if(src.size()<=2) return nil_typet(); typet subtype=java_type_from_string(src.substr(1, std::string::npos)); return java_reference_type(java_array_type(subtype)); } case 'F': return java_float_type(); case 'D': return java_double_type(); case 'I': return java_int_type(); case 'C': return java_char_type(); case 'Z': return java_boolean_type(); case 'V': return java_void_type(); case 'J': return java_long_type(); case 'L': { // ends on ; if(src[src.size()-1]!=';') return nil_typet(); std::string identifier="java::"+src.substr(1, src.size()-2); for(unsigned i=0; i<identifier.size(); i++) if(identifier[i]=='/') identifier[i]='.'; reference_typet result; result.subtype()=symbol_typet(identifier); return result; } default: return nil_typet(); } }
void disjunctive_polynomial_accelerationt::assert_for_values( scratch_programt &program, std::map<exprt, exprt> &values, std::set<std::pair<expr_listt, exprt> > &coefficients, int num_unwindings, goto_programt &loop_body, exprt &target) { // First figure out what the appropriate type for this expression is. typet expr_type = nil_typet(); for (std::map<exprt, exprt>::iterator it = values.begin(); it != values.end(); ++it) { if (expr_type == nil_typet()) { expr_type = it->first.type(); } else { expr_type = join_types(expr_type, it->first.type()); } } // Now set the initial values of the all the variables... for (std::map<exprt, exprt>::iterator it = values.begin(); it != values.end(); ++it) { program.assign(it->first, it->second); } // Now unwind the loop as many times as we need to. for (int i = 0; i < num_unwindings; i++) { program.append(loop_body); } // Now build the polynomial for this point and assert it fits. exprt rhs = nil_exprt(); for (std::set<std::pair<expr_listt, exprt> >::iterator it = coefficients.begin(); it != coefficients.end(); ++it) { exprt concrete_value = from_integer(1, expr_type); for (expr_listt::const_iterator e_it = it->first.begin(); e_it != it->first.end(); ++e_it) { exprt e = *e_it; if (e == loop_counter) { mult_exprt mult(from_integer(num_unwindings, expr_type), concrete_value); mult.swap(concrete_value); } else { std::map<exprt, exprt>::iterator v_it = values.find(e); assert(v_it != values.end()); mult_exprt mult(concrete_value, v_it->second); mult.swap(concrete_value); } } // OK, concrete_value now contains the value of all the relevant variables // multiplied together. Create the term concrete_value*coefficient and add // it into the polynomial. typecast_exprt cast(it->second, expr_type); exprt term = mult_exprt(concrete_value, cast); if (rhs.is_nil()) { rhs = term; } else { rhs = plus_exprt(rhs, term); } } rhs = typecast_exprt(rhs, target.type()); // We now have the RHS of the polynomial. Assert that this is equal to the // actual value of the variable we're fitting. exprt polynomial_holds = equal_exprt(target, rhs); // Finally, assert that the polynomial equals the variable we're fitting. goto_programt::targett assumption = program.add_instruction(ASSUME); assumption->guard = polynomial_holds; }
typet get_type(const format_tokent &token) { switch(token.type) { case format_tokent::INT: switch(token.length_modifier) { case format_tokent::LEN_h: if(token.representation==format_tokent::SIGNED_DEC) return signed_char_type(); else return unsigned_char_type(); case format_tokent::LEN_hh: if(token.representation==format_tokent::SIGNED_DEC) return signed_short_int_type(); else return unsigned_short_int_type(); case format_tokent::LEN_l: if(token.representation==format_tokent::SIGNED_DEC) return signed_long_int_type(); else return unsigned_long_int_type(); case format_tokent::LEN_ll: if(token.representation==format_tokent::SIGNED_DEC) return signed_long_long_int_type(); else return unsigned_long_long_int_type(); default: if(token.representation==format_tokent::SIGNED_DEC) return signed_int_type(); else return unsigned_int_type(); } case format_tokent::FLOAT: switch(token.length_modifier) { case format_tokent::LEN_l: return double_type(); case format_tokent::LEN_L: return long_double_type(); default: return float_type(); } case format_tokent::CHAR: switch(token.length_modifier) { case format_tokent::LEN_l: return wchar_t_type(); default: return char_type(); } case format_tokent::POINTER: return pointer_type(void_type()); case format_tokent::STRING: switch(token.length_modifier) { case format_tokent::LEN_l: return array_typet(wchar_t_type(), nil_exprt()); default: return array_typet(char_type(), nil_exprt()); } default: return nil_typet(); } }