void c_typecastt::implicit_typecast_arithmetic( exprt &expr, c_typet c_type) { typet new_type; const typet &expr_type=ns.follow(expr.type()); switch(c_type) { case PTR: if(expr_type.id()==ID_array) { new_type.id(ID_pointer); new_type.subtype()=expr_type.subtype(); break; } return; case BOOL: new_type=bool_typet(); break; case CHAR: assert(false); // should always be promoted to int case UCHAR: assert(false); // should always be promoted to int case SHORT: assert(false); // should always be promoted to int case USHORT: assert(false); // should always be promoted to int case INT: new_type=int_type(); break; case UINT: new_type=uint_type(); break; case LONG: new_type=long_int_type(); break; case ULONG: new_type=long_uint_type(); break; case LONGLONG: new_type=long_long_int_type(); break; case ULONGLONG: new_type=long_long_uint_type(); break; case SINGLE: new_type=float_type(); break; case DOUBLE: new_type=double_type(); break; case LONGDOUBLE: new_type=long_double_type(); break; case RATIONAL: new_type=rational_typet(); break; case REAL: new_type=real_typet(); break; case INTEGER: new_type=integer_typet(); break; case COMPLEX: return; // do nothing default: return; } if(new_type!=expr_type) { if(new_type.id()==ID_pointer && expr_type.id()==ID_array) { exprt index_expr(ID_index, expr_type.subtype()); index_expr.reserve_operands(2); index_expr.move_to_operands(expr); index_expr.copy_to_operands(gen_zero(index_type())); expr=exprt(ID_address_of, new_type); expr.move_to_operands(index_expr); } else do_typecast(expr, new_type); } }
void c_typecastt::implicit_typecast_arithmetic( exprt &expr, c_typet c_type) { typet new_type; const typet &expr_type=ns.follow(expr.type()); switch(c_type) { case PTR: if(expr_type.id()==ID_array) { new_type.id(ID_pointer); new_type.subtype()=expr_type.subtype(); break; } return; case BOOL: assert(false); // should always be promoted to int case CHAR: assert(false); // should always be promoted to int case UCHAR: assert(false); // should always be promoted to int case SHORT: assert(false); // should always be promoted to int case USHORT: assert(false); // should always be promoted to int case INT: new_type=signed_int_type(); break; case UINT: new_type=unsigned_int_type(); break; case LONG: new_type=signed_long_int_type(); break; case ULONG: new_type=unsigned_long_int_type(); break; case LONGLONG: new_type=signed_long_long_int_type(); break; case ULONGLONG: new_type=unsigned_long_long_int_type(); break; case SINGLE: new_type=float_type(); break; case DOUBLE: new_type=double_type(); break; case LONGDOUBLE: new_type=long_double_type(); break; case FLOAT128: new_type=ieee_float_spect::quadruple_precision().to_type(); break; case RATIONAL: new_type=rational_typet(); break; case REAL: new_type=real_typet(); break; case INTEGER: new_type=integer_typet(); break; case COMPLEX: return; // do nothing default: return; } if(new_type!=expr_type) do_typecast(expr, new_type); }
void ansi_c_convert_typet::write(typet &type) { type.clear(); // first, do "other" if(!other.empty()) { if( double_cnt || float_cnt || signed_cnt || unsigned_cnt || int_cnt || bool_cnt || short_cnt || char_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || ptr32_cnt || ptr64_cnt || long_cnt) { err_location(location); error("illegal type modifier for defined type"); throw 0; } if(other.size() != 1) { err_location(location); error("illegal combination of defined types"); throw 0; } type.swap(other.front()); } else if(double_cnt || float_cnt) { if( signed_cnt || unsigned_cnt || int_cnt || bool_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || ptr32_cnt || ptr64_cnt || short_cnt || char_cnt) { err_location(location); error("cannot conbine integer type with float"); throw 0; } if(double_cnt && float_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } if(long_cnt == 0) { if(double_cnt != 0) type = double_type(); else type = float_type(); } else if(long_cnt == 1 || long_cnt == 2) { if(double_cnt != 0) type = long_double_type(); else { err_location(location); error("conflicting type modifiers"); throw 0; } } else { err_location(location); error("illegal type modifier for float"); throw 0; } } else if(bool_cnt) { if( signed_cnt || unsigned_cnt || int_cnt || short_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || ptr32_cnt || ptr64_cnt || char_cnt || long_cnt) { err_location(location); error("illegal type modifier for boolean type"); throw 0; } type.id("bool"); } else if(ptr32_cnt || ptr64_cnt) { type.id("pointer"); type.subtype() = typet("empty"); } else { // it is integer -- signed or unsigned? if(signed_cnt && unsigned_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } if(unsigned_cnt) type.id("unsignedbv"); else if(signed_cnt) type.id("signedbv"); else { if(char_cnt) type.id(config.ansi_c.char_is_unsigned ? "unsignedbv" : "signedbv"); else type.id("signedbv"); } // get width unsigned width; if(int8_cnt || int16_cnt || int32_cnt || int64_cnt) { if(long_cnt || char_cnt || short_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } if(int8_cnt) width = 1 * 8; else if(int16_cnt) width = 2 * 8; else if(int32_cnt) width = 4 * 8; else if(int64_cnt) width = 8 * 8; else abort(); } else if(short_cnt) { if(long_cnt || char_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } width = config.ansi_c.short_int_width; } else if(char_cnt) { if(long_cnt) { err_location(location); error("illegal type modifier for char type"); throw 0; } width = config.ansi_c.char_width; } else if(long_cnt == 0) { width = config.ansi_c.int_width; } else if(long_cnt == 1) { width = config.ansi_c.long_int_width; } else if(long_cnt == 2) { width = config.ansi_c.long_long_int_width; } else { err_location(location); error("illegal type modifier for integer type"); throw 0; } type.width(width); } c_qualifiers.write(type); }
exprt convert_float_literal(const std::string &src) { mp_integer significand; mp_integer exponent; bool is_float, is_long, is_imaginary; bool is_decimal, is_float80, is_float128; // GCC extensions unsigned base; parse_float(src, significand, exponent, base, is_float, is_long, is_imaginary, is_decimal, is_float80, is_float128); exprt result=exprt(ID_constant); result.set(ID_C_cformat, src); // In ANSI-C, float literals are double by default, // unless marked with 'f'. // All of these can be complex as well. // This can be overriden with // config.ansi_c.single_precision_constant. if(is_float) result.type()=float_type(); else if(is_long) result.type()=long_double_type(); else if(is_float80) { result.type()=ieee_float_spect(64, 15).to_type(); result.type().set(ID_C_c_type, ID_long_double); } else if(is_float128) { result.type()=ieee_float_spect::quadruple_precision().to_type(); result.type().set(ID_C_c_type, ID_gcc_float128); } else { // default if(config.ansi_c.single_precision_constant) result.type()=float_type(); // default else result.type()=double_type(); // default } if(is_decimal) { // TODO - should set ID_gcc_decimal32/ID_gcc_decimal64/ID_gcc_decimal128, // but these aren't handled anywhere } if(config.ansi_c.use_fixed_for_float) { unsigned width=result.type().get_int(ID_width); unsigned fraction_bits; const irep_idt integer_bits=result.type().get(ID_integer_bits); assert(width!=0); if(integer_bits==irep_idt()) fraction_bits=width/2; // default else fraction_bits=width-safe_string2int(id2string(integer_bits)); mp_integer factor=mp_integer(1)<<fraction_bits; mp_integer value=significand*factor; if(value!=0) { if(exponent<0) value/=power(base, -exponent); else { value*=power(base, exponent); if(value>=power(2, width-1)) { // saturate: use "biggest value" value=power(2, width-1)-1; } else if(value<=-power(2, width-1)-1) { // saturate: use "smallest value" value=-power(2, width-1); } } } result.set(ID_value, integer2binary(value, width)); } else { ieee_floatt a; a.spec=to_floatbv_type(result.type()); if(base==10) a.from_base10(significand, exponent); else if(base==2) // hex a.build(significand, exponent); else assert(false); result.set(ID_value, integer2binary(a.pack(), a.spec.width())); } if(is_imaginary) { complex_typet complex_type; complex_type.subtype()=result.type(); exprt complex_expr(ID_complex, complex_type); complex_expr.operands().resize(2); complex_expr.op0()=gen_zero(result.type()); complex_expr.op1()=result; return complex_expr; } return result; }
void ansi_c_convert_typet::write(typet &type) { type.clear(); // first, do "other" if(!other.empty()) { if(double_cnt || float_cnt || signed_cnt || unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt || short_cnt || char_cnt || complex_cnt || long_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_float128_cnt || gcc_int128_cnt || bv_cnt) { err_location(location); error("illegal type modifier for defined type"); throw 0; } if(other.size()!=1) { err_location(location); error("illegal combination of defined types"); throw 0; } type.swap(other.front()); } else if(gcc_float128_cnt) { if(signed_cnt || unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_int128_cnt || bv_cnt || short_cnt || char_cnt) { err_location(location); error("cannot combine integer type with float"); throw 0; } if(long_cnt || double_cnt || float_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } type=long_double_type(); } else if(double_cnt || float_cnt) { if(signed_cnt || unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_int128_cnt|| bv_cnt || short_cnt || char_cnt) { err_location(location); error("cannot combine integer type with float"); throw 0; } if(double_cnt && float_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } if(long_cnt==0) { if(double_cnt!=0) type=double_type(); else type=float_type(); } else if(long_cnt==1 || long_cnt==2) { if(double_cnt!=0) type=long_double_type(); else { err_location(location); error("conflicting type modifiers"); throw 0; } } else { err_location(location); error("illegal type modifier for float"); throw 0; } } else if(c_bool_cnt) { if(signed_cnt || unsigned_cnt || int_cnt || short_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_float128_cnt || bv_cnt || proper_bool_cnt || char_cnt || long_cnt) { err_location(location); error("illegal type modifier for C boolean type"); throw 0; } type.id(ID_unsignedbv); type.set(ID_width, config.ansi_c.bool_width); type.set(ID_C_c_type, ID_bool); } else if(proper_bool_cnt) { if(signed_cnt || unsigned_cnt || int_cnt || short_cnt || int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_float128_cnt || bv_cnt || char_cnt || long_cnt) { err_location(location); error("illegal type modifier for proper boolean type"); throw 0; } type.id(ID_bool); } else if(complex_cnt && !char_cnt && !signed_cnt && !unsigned_cnt && !short_cnt && !gcc_int128_cnt) { // the "default" for complex is double type=double_type(); } else { // it is integer -- signed or unsigned? if(signed_cnt && unsigned_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } else if(unsigned_cnt) type.id(ID_unsignedbv); else if(signed_cnt) type.id(ID_signedbv); else { if(char_cnt) type.id(config.ansi_c.char_is_unsigned?ID_unsignedbv:ID_signedbv); else type.id(ID_signedbv); } // get width unsigned width; if(gcc_mode_QI || gcc_mode_HI || gcc_mode_SI || gcc_mode_DI) { if(gcc_mode_QI) width=1*8; else if(gcc_mode_HI) width=2*8; else if(gcc_mode_SI) width=4*8; else if(gcc_mode_DI) width=8*8; else assert(false); } else if(int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_int128_cnt || bv_cnt) { if(long_cnt || char_cnt || short_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } if(int8_cnt) width=1*8; else if(int16_cnt) width=2*8; else if(int32_cnt) width=4*8; else if(int64_cnt) width=8*8; else if(bv_cnt) width=bv_width; else if(gcc_int128_cnt) width=128; else assert(false); } else if(short_cnt) { if(long_cnt || char_cnt) { err_location(location); error("conflicting type modifiers"); throw 0; } width=config.ansi_c.short_int_width; } else if(char_cnt) { if(long_cnt) { err_location(location); error("illegal type modifier for char type"); throw 0; } width=config.ansi_c.char_width; } else if(long_cnt==0) { width=config.ansi_c.int_width; } else if(long_cnt==1) { width=config.ansi_c.long_int_width; } else if(long_cnt==2) { width=config.ansi_c.long_long_int_width; } else { err_location(location); error("illegal type modifier for integer type"); throw 0; } type.set(ID_width, width); } if(vector_size.is_not_nil()) { vector_typet new_type; new_type.size()=vector_size; new_type.location()=vector_size.location(); new_type.subtype().swap(type); type=new_type; } if(complex_cnt) { // These take more or less arbitrary subtypes. complex_typet new_type; new_type.location()=location; new_type.subtype()=type; type.swap(new_type); } c_qualifiers.write(type); if(packed) type.set(ID_C_packed, true); if(aligned) type.set(ID_C_alignment, alignment); }
exprt convert_float_literal(const std::string &src) { mp_integer significand; mp_integer exponent; bool is_float, is_long, is_fixed, is_accum; unsigned base; parse_float(src, significand, exponent, base, is_float, is_long, is_fixed, is_accum); exprt result=exprt(ID_constant); result.set(ID_C_cformat, src); // In ANSI-C, float literals are double by default // unless marked with 'f'. if(is_float) { result.type()=float_type(); result.type().set(ID_C_cpp_type, ID_float); } else if(is_long) { result.type()=long_double_type(); result.type().set(ID_C_cpp_type, ID_long_double); } else if(is_fixed) { result.type()=fixed_type(); result.type().set(ID_C_cpp_type, ID_fixed); } else if(is_accum) { result.type()=accum_type(); result.type().set(ID_C_cpp_type, ID_accum); } else { result.type()=double_type(); // default result.type().set(ID_C_cpp_type, ID_double); } if(config.ansi_c.use_fixed_for_float || is_fixed || is_accum) { unsigned width=result.type().get_int(ID_width); unsigned fraction_bits; const irep_idt integer_bits=result.type().get(ID_integer_bits); assert(width!=0); if(is_fixed) { fraction_bits = width - 1; } else if(is_accum) { fraction_bits = width - 9; } else if(integer_bits==irep_idt()) fraction_bits=width/2; // default else fraction_bits=width-safe_string2int(id2string(integer_bits)); mp_integer factor=mp_integer(1)<<fraction_bits; mp_integer value=significand*factor; if(value!=0) { if(exponent<0) value/=power(base, -exponent); else { value*=power(base, exponent); if(value>=power(2, width-1)) { // saturate: use "biggest value" value=power(2, width-1)-1; } else if(value<=-power(2, width-1)-1) { // saturate: use "smallest value" value=-power(2, width-1); } } } result.set(ID_value, integer2binary(value, width)); } else { ieee_floatt a; a.spec=to_floatbv_type(result.type()); if(base==10) a.from_base10(significand, exponent); else if(base==2) // hex a.build(significand, exponent); else assert(false); result.set(ID_value, integer2binary(a.pack(), a.spec.width())); } return result; }
static void call(Iterator const& first, Iterator const& last, long double& attr) { Iterator first_ = first; qi::parse(first_, last, long_double_type(), attr); }
void convert_float_literal(const std::string &src, exprt &dest) { mp_integer significand; mp_integer exponent; bool is_float, is_long; unsigned base; parse_float(src, significand, exponent, base, is_float, is_long); dest = exprt("constant"); dest.cformat(src); if(is_float) { dest.type() = float_type(); dest.type().set("#cpp_type", "float"); } else if(is_long) { dest.type() = long_double_type(); dest.type().set("#cpp_type", "long_double"); } else { dest.type() = double_type(); dest.type().set("#cpp_type", "double"); } if(config.ansi_c.use_fixed_for_float) { unsigned width = atoi(dest.type().width().c_str()); unsigned fraction_bits; const std::string &integer_bits = dest.type().integer_bits().as_string(); if(integer_bits == "") fraction_bits = width / 2; else fraction_bits = width - atoi(integer_bits.c_str()); mp_integer factor = mp_integer(1) << fraction_bits; mp_integer value = significand * factor; if(value != 0) { if(exponent < 0) value /= power(base, -exponent); else { value *= power(base, exponent); if(value >= power(2, width - 1)) { // saturate: use "biggest value" value = power(2, width - 1) - 1; } else if(value <= -power(2, width - 1) - 1) { // saturate: use "smallest value" value = -power(2, width - 1); } } } dest.value(integer2binary(value, width)); } else { ieee_floatt a; a.spec = to_floatbv_type(dest.type()); if(base == 10) a.from_base10(significand, exponent); else if(base == 2) // hex a.build(significand, exponent); else assert(false); dest.value(integer2binary(a.pack(), a.spec.width())); } }
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(); } }