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();
}
}
