inline void amp_mod_simd(float_type * out, const float_type * in1, const float_type * in2,
const float_type amount, unsigned int n)
{
for (unsigned int i = 0; i != n/4; ++i) {
out[0] = in1[0] * (float_type(1) + in2[0] * amount);
out[1] = in1[1] * (float_type(1) + in2[1] * amount);
out[2] = in1[2] * (float_type(1) + in2[2] * amount);
out[3] = in1[3] * (float_type(1) + in2[3] * amount);
out += 4;
in1 += 4;
in2 += 4;
}
}
FloatLiteral (Token _token, std::string _value) : Expression(_token, nullptr, Kind::FloatLit, nullptr) {
type = std::unique_ptr<Type>(new BaseType(_token, float_type(_value)));
bool positive = num_is_positive(_value);
value = float_value(_value);
if (!positive) {
value = -value;
}
}
void FloatChecker::convert(Object & o) const
{
if(! o.is<Float>())
{
Float f = float_type(o);
o.set_object(f);
}
}
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);
}
}
hdf5_iprimitive::read_hdf5_dataset
(
float* t,
std::size_t data_count,
std::size_t object_number
)
{
hdf5_datatype float_type(H5T_NATIVE_FLOAT);
read_dataset_basic(t, data_count, float_type, object_number);
}
hdf5_oprimitive::write_hdf5_dataset
(
float const* t,
std::size_t data_count,
std::size_t object_number
)
{
hdf5_datatype float_type(H5T_NATIVE_FLOAT);
write_dataset_basic(t, data_count, float_type, object_number);
}
inline void amp_mod(float_type * out, const float_type * in1, const float_type * in2,
float_type amount, const float_type amount_slope,
unsigned int n)
{
for (unsigned int i = 0; i != n; ++i)
{
out[i] = in1[i] * (float_type(1) + in2[i] * amount);
amount += amount_slope;
}
}
float_type wcstod(const wchar_t* str, wchar_t** end, float_type strtod_fn(const char*, char**)) {
const wchar_t* original_str = str;
while (iswspace(*str)) {
str++;
}
// What's the longest span of the input that might be part of the float?
size_t max_len = wcsspn(str, L"-+0123456789.xXeEpP()nNaAiIfFtTyY");
// We know the only valid characters are ASCII, so convert them by brute force.
char* ascii_str = new char[max_len + 1];
if (!ascii_str) return float_type();
for (size_t i = 0; i < max_len; ++i) {
ascii_str[i] = str[i] & 0xff;
}
ascii_str[max_len] = 0;
// Set up a fake FILE that points to those ASCII characters, for `parsefloat`.
FILE f;
__sfileext fext;
_FILEEXT_SETUP(&f, &fext);
f._flags = __SRD;
f._bf._base = f._p = reinterpret_cast<unsigned char*>(ascii_str);
f._bf._size = f._r = max_len;
f._read = [](void*, char*, int) { return 0; }; // aka `eofread`, aka "no more data".
f._lb._base = NULL;
// Ask `parsefloat` to look at the same data more carefully.
// We can't just do this straight away because we can't construct a suitable FILE*
// in the absence of any `fwmemopen` analogous to `fmemopen`. And we don't want to
// duplicate the `parsefloat` logic. We also don't want to actually have to have wchar_t
// implementations of the ASCII `strtod` logic (though if you were designing a libc
// from scratch, you'd probably want to just make that more generic and lose all the
// cruft on top).
size_t actual_len = parsefloat(&f, ascii_str, ascii_str + max_len);
// Finally let the ASCII conversion function do the work.
char* ascii_end;
float_type result = strtod_fn(ascii_str, &ascii_end);
if (ascii_end != ascii_str + actual_len) abort();
if (end) {
if (actual_len == 0) {
// There was an error. We need to set the end pointer back to the original string, not the
// one we advanced past the leading whitespace.
*end = const_cast<wchar_t*>(original_str);
} else {
*end = const_cast<wchar_t*>(str) + actual_len;
}
}
delete[] ascii_str;
return result;
}
HALMD_GPU_ENABLED bool cuboid<dimension, float_type>::operator()(vector_type const& r) const
{
bool inside = true;
vector_type const dr = r - lowest_corner_;
for (int i = 0; i < dimension; ++i) {
if (dr[i] < float_type(0) || dr[i] > edge_length_[i]) {
inside = false;
}
}
return inside;
}
VerificationType VerificationType::from_tag(u1 tag) {
switch (tag) {
case ITEM_Top: return bogus_type();
case ITEM_Integer: return integer_type();
case ITEM_Float: return float_type();
case ITEM_Double: return double_type();
case ITEM_Long: return long_type();
case ITEM_Null: return null_type();
default:
ShouldNotReachHere();
return bogus_type();
}
}
//--------------------------------------------------------------------------
// Function: CommonFG::openFloatType
///\brief Opens the named floating-point datatype at this location.
///\param name - IN: Name of the floating-point datatype to open
///\return FloatType instance
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
FloatType CommonFG::openFloatType( const char* name ) const
{
// Call C function H5Topen2 to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
throwException("openFloatType", "H5Topen2 failed");
// No failure, create and return the FloatType object
FloatType float_type(type_id);
return(float_type);
}
int set_unistate(const char *name, float *val, int count)
{
int sidx = get_unistate_index(name);
if(sidx < 0) {
StType type = float_type(count);
if(type == ST_UNKNOWN) {
error_log("invalid element count (%d) while setting previously unknown unistate item \"%s\"\n",
count, name);
return -1;
}
sidx = add_unistate(name, type);
}
set_unistate(sidx, val);
return sidx;
}
double1 native_sqrt( const expression<E1>& e1, double_type )
{
typedef unary<E1,cal_unary_sqrt<typename E1::value_type> > sqrt_type;
#if defined(__CAL_H__)
if( Source::info().available && Source::info().target>=CAL_TARGET_CYPRESS ) return sqrt_type(e1());
#endif
double1 w,x;
int1 e;
w = e1();
x = frexp(w,e);
x = cast_type<double1>( native_sqrt(cast_type<float1>(x),float_type()) );
x = select( e&0x1, 1.41421356237309504880*x, x );
x = ldexp(x,e>>1);
return x;
}
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);
}
//! Calculate poles (chebyshev)
void chebyshev_s(std::vector<complex<float_type> >& poles, std::vector<complex<float_type> >& zeros, bool lpf,
float_type wp, float_type epi, long n, long n2) {
long l = 0;
if (n % 2 == 0) l = 1;
float_type arg;
float_type x = 1 / epi;
float_type asinh = log(x + sqrt(1.0 + x * x));
float_type v0 = asinh / (float_type(n));
float_type sm = sinh(v0);
float_type cm = cosh(v0);
for (int j = 0; j < n2; j++) {
arg = -0.5 * PI * l / ((float_type)(n));
if (lpf) {
poles[j] = -wp * complex<float_type>(-sm * cos(arg), cm * sin(arg));
zeros[j] = FLT_MAX;
} else {
poles[j] = -1.0 / (wp * complex<float_type>(-sm * cos(arg), cm * sin(arg)));
zeros[j] = 0;
}
l += 2;
}
}
void phase_space<modules_type>::test()
{
float_type const epsilon = std::numeric_limits<float_type>::epsilon();
auto& input_position = input_position_sample->data();
auto& input_velocity = input_velocity_sample->data();
auto& input_species = input_species_sample->data();
// prepare input sample
BOOST_CHECK_EQUAL(input_position.size(), accumulate(npart.begin(), npart.end(), 0u));
BOOST_CHECK_EQUAL(input_velocity.size(), accumulate(npart.begin(), npart.end(), 0u));
for (unsigned int i = 0, n = 0; i < npart.size(); ++i) { // iterate over particle species
for (unsigned int j = 0; j < npart[i]; ++n, ++j) { // iterate over particles
vector_type& r = input_position[n];
vector_type& v = input_velocity[n];
unsigned int& type = input_species[n];
r[0] = float_type(j) + float_type(1) / (i + 1); //< a large, non-integer value
r[1] = 0;
r[dimension - 1] = - static_cast<float_type>(j);
v[0] = static_cast<float_type>(i);
v[1] = 0;
v[dimension - 1] = float_type(1) / (j + 1);
type = i;
}
}
// copy input sample to particle
std::shared_ptr<particle_group_type> particle_group = std::make_shared<particle_group_type>(particle);
{
auto phase_space = phase_space_type(particle, particle_group, box);
phase_space.set("position", input_position_sample);
phase_space.set("velocity", input_velocity_sample);
phase_space.set("species", input_species_sample);
phase_space.set("mass", input_mass_sample);
}
// randomly permute particles in memory, do it three times since permutations are
// not commutative
shuffle(particle, random);
shuffle(particle, random);
shuffle(particle, random);
// compare output and input, copy GPU sample to host before
typename modules_type::samples_type result(phase_space_type(particle, particle_group, box));
auto const& result_position = result.position->data();
auto const& result_velocity = result.velocity->data();
auto const& result_species = result.species->data();
BOOST_CHECK_EQUAL(result_position.size(), accumulate(npart.begin(), npart.end(), 0u));
for (unsigned int i = 0, n = 0; i < npart.size(); ++i) { // iterate over particle species
for (unsigned int j = 0; j < npart[i]; ++n, ++j) { // iterate over particles
// compare positions with a tolerance due to mapping to and from the periodic box
for (unsigned int k = 0; k < dimension; ++k) {
BOOST_CHECK_CLOSE_FRACTION(result_position[n][k], input_position[n][k], 10 * epsilon);
}
}
}
// compare velocities directly as they should not have been modified
BOOST_CHECK_EQUAL_COLLECTIONS(
result_velocity.begin(), result_velocity.end()
, input_velocity.begin(), input_velocity.end()
);
// compare particle species
BOOST_CHECK_EQUAL_COLLECTIONS(
result_species.begin(), result_species.end()
, input_species.begin(), input_species.end()
);
}
* Construct unit lattice primitive of given shape.
*
* @param shape number of unit cells per dimension
*/
explicit HALMD_GPU_ENABLED close_packed_lattice(shape_type const& shape) : shape_(shape) {}
/**
* Returns lattice position for given particle index.
*
* @param n particle index with 0 ≤ index < size()
*/
HALMD_GPU_ENABLED result_type operator()(size_type n) const
{
shape_type cell = offset_to_multi_index(n >> 1, shape_);
result_type r;
r[0] = cell[0] + ((n & 1) * 2 + 1) / float_type(4);
r[1] = cell[1] + ((n & 1) * 2 + 1) / float_type(4);
return r;
}
/**
* Returns number of unit cells per dimension.
*/
HALMD_GPU_ENABLED shape_type const& shape() const
{
return shape_;
}
/**
* Returns total number of lattice points.
*/
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;
}
double1 fast_sqrt( const expression<E1>& a, float_type )
{
return native_sqrt(a(),float_type());
}
inline void amp_mod(float_type * out, const float_type * in1, const float_type * in2,
const float_type * amount, unsigned int n)
{
for (unsigned int i = 0; i != n; ++i)
out[i] = in1[i] * (float_type(1) + in2[i] * amount[i]);
}
static void
call(Iterator const& first, Iterator const& last, float& attr)
{
Iterator first_ = first;
qi::parse(first_, last, float_type(), attr);
}
void c_typecheck_baset::typecheck_type(typet &type)
{
// we first convert, and then check
{
ansi_c_convert_typet ansi_c_convert_type(get_message_handler());
ansi_c_convert_type.read(type);
ansi_c_convert_type.write(type);
}
if(type.id()==ID_already_typechecked)
{
// need to preserve any qualifiers
c_qualifierst c_qualifiers(type);
c_qualifiers+=c_qualifierst(type.subtype());
bool packed=type.get_bool(ID_C_packed);
exprt alignment=static_cast<const exprt &>(type.find(ID_C_alignment));
irept _typedef=type.find(ID_C_typedef);
type=type.subtype();
c_qualifiers.write(type);
if(packed)
type.set(ID_C_packed, true);
if(alignment.is_not_nil())
type.add(ID_C_alignment, alignment);
if(_typedef.is_not_nil())
type.add(ID_C_typedef, _typedef);
return; // done
}
// do we have alignment?
if(type.find(ID_C_alignment).is_not_nil())
{
exprt &alignment=static_cast<exprt &>(type.add(ID_C_alignment));
if(alignment.id()!=ID_default)
{
typecheck_expr(alignment);
make_constant(alignment);
}
}
if(type.id()==ID_code)
typecheck_code_type(to_code_type(type));
else if(type.id()==ID_array)
typecheck_array_type(to_array_type(type));
else if(type.id()==ID_pointer)
typecheck_type(type.subtype());
else if(type.id()==ID_struct ||
type.id()==ID_union)
typecheck_compound_type(to_struct_union_type(type));
else if(type.id()==ID_c_enum)
typecheck_c_enum_type(type);
else if(type.id()==ID_c_enum_tag)
typecheck_c_enum_tag_type(to_c_enum_tag_type(type));
else if(type.id()==ID_c_bit_field)
typecheck_c_bit_field_type(to_c_bit_field_type(type));
else if(type.id()==ID_typeof)
typecheck_typeof_type(type);
else if(type.id()==ID_symbol)
typecheck_symbol_type(type);
else if(type.id()==ID_vector)
typecheck_vector_type(to_vector_type(type));
else if(type.id()==ID_custom_unsignedbv ||
type.id()==ID_custom_signedbv ||
type.id()==ID_custom_floatbv ||
type.id()==ID_custom_fixedbv)
typecheck_custom_type(type);
else if(type.id()==ID_gcc_attribute_mode)
{
// get that mode
irep_idt mode=type.get(ID_size);
// A list of all modes ist at
// http://www.delorie.com/gnu/docs/gcc/gccint_53.html
typecheck_type(type.subtype());
typet underlying_type=type.subtype();
// gcc allows this, but clang doesn't; it's a compiler hint only,
// but we'll try to interpret it the GCC way
if(underlying_type.id()==ID_c_enum_tag)
{
underlying_type=
follow_tag(to_c_enum_tag_type(underlying_type)).subtype();
assert(underlying_type.id()==ID_signedbv ||
underlying_type.id()==ID_unsignedbv);
}
if(underlying_type.id()==ID_signedbv ||
underlying_type.id()==ID_unsignedbv)
{
bool is_signed=underlying_type.id()==ID_signedbv;
typet result;
if(mode=="__QI__") // 8 bits
result=is_signed?signed_char_type():unsigned_char_type();
else if(mode=="__byte__") // 8 bits
result=is_signed?signed_char_type():unsigned_char_type();
else if(mode=="__HI__") // 16 bits
result=is_signed?signed_short_int_type():unsigned_short_int_type();
else if(mode=="__SI__") // 32 bits
result=is_signed?signed_int_type():unsigned_int_type();
else if(mode=="__word__") // long int, we think
result=is_signed?signed_long_int_type():unsigned_long_int_type();
else if(mode=="__pointer__") // we think this is size_t/ssize_t
result=is_signed?signed_size_type():size_type();
else if(mode=="__DI__") // 64 bits
{
if(config.ansi_c.long_int_width==64)
result=is_signed?signed_long_int_type():unsigned_long_int_type();
else
{
assert(config.ansi_c.long_long_int_width==64);
result=
is_signed?signed_long_long_int_type():unsigned_long_long_int_type();
}
}
else if(mode=="__TI__") // 128 bits
result=is_signed?gcc_signed_int128_type():gcc_unsigned_int128_type();
else if(mode=="__V2SI__") // vector of 2 ints, deprecated by gcc
result=
vector_typet(
is_signed?signed_int_type():unsigned_int_type(),
from_integer(2, size_type()));
else if(mode=="__V4SI__") // vector of 4 ints, deprecated by gcc
result=
vector_typet(
is_signed?signed_int_type():unsigned_int_type(),
from_integer(4, size_type()));
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
if(type.subtype().id()==ID_c_enum_tag)
{
const irep_idt &tag_name=
to_c_enum_tag_type(type.subtype()).get_identifier();
symbol_tablet::symbolst::iterator entry=
symbol_table.symbols.find(tag_name);
assert(entry!=symbol_table.symbols.end());
entry->second.type.subtype()=result;
}
type=result;
}
else if(underlying_type.id()==ID_floatbv)
{
typet result;
if(mode=="__SF__") // 32 bits
result=float_type();
else if(mode=="__DF__") // 64 bits
result=double_type();
else if(mode=="__TF__") // 128 bits
result=gcc_float128_type();
else if(mode=="__V2SF__") // vector of 2 floats, deprecated by gcc
result=vector_typet(float_type(), from_integer(2, size_type()));
else if(mode=="__V2DF__") // vector of 2 doubles, deprecated by gcc
result=vector_typet(double_type(), from_integer(2, size_type()));
else if(mode=="__V4SF__") // vector of 4 floats, deprecated by gcc
result=vector_typet(float_type(), from_integer(4, size_type()));
else if(mode=="__V4DF__") // vector of 4 doubles, deprecated by gcc
result=vector_typet(double_type(), from_integer(4, size_type()));
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
type=result;
}
else if(underlying_type.id()==ID_complex)
{
// gcc allows this, but clang doesn't -- see enums above
typet result;
if(mode=="__SC__") // 32 bits
result=float_type();
else if(mode=="__DC__") // 64 bits
result=double_type();
else if(mode=="__TC__") // 128 bits
result=gcc_float128_type();
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
type=complex_typet(result);
}
else
{
error().source_location=type.source_location();
error() << "attribute mode `" << mode
<< "' applied to inappropriate type `"
<< to_string(type) << "'" << eom;
throw 0;
}
}
// do a mild bit of rule checking
if(type.get_bool(ID_C_restricted) &&
type.id()!=ID_pointer &&
type.id()!=ID_array)
{
error().source_location=type.source_location();
error() << "only a pointer can be 'restrict'" << eom;
throw 0;
}
}
float_type operator()(float_type const & f, float_type const & limit) const
{
float_type zero(0);
float_type neg = zero - float_type(limit);
return max_(neg, min_(f, limit));
}
inline float_type round(float_type const & arg)
{
return std::floor(arg + float_type(0.5));
}
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);
}
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);
}
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()));
}
}
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;
}
inline float_type reciprocal(float_type in)
{
return float_type(1) / in;
}
bool almost_equal(float_type a, float_type b, int multiplier = 1)
{
float_type scale = a==float_type(0.0) ? float_type(1.0) : a;
return std::abs((a-b)/scale) < float_type(multiplier) * std::numeric_limits<float_type>::epsilon();
}