void c_typecheck_baset::typecheck_type(typet &type)
{
// we first convert, and then check
// 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)
{
}
else if(type.id()==ID_c_bitfield)
typecheck_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);
// do a bit of rule checking
if(type.get_bool(ID_C_restricted) &&
type.id()!=ID_pointer &&
type.id()!=ID_array)
{
err_location(type);
error("only a pointer can be 'restrict'");
throw 0;
}
}
void cpp_typecheckt::typecheck_type(typet &type)
{
assert(!type.id().empty());
assert(type.is_not_nil());
try
{
cpp_convert_plain_type(type);
}
catch(const char *err)
{
error().source_location=type.source_location();
error() << err << eom;
throw 0;
}
catch(const std::string &err)
{
error().source_location=type.source_location();
error() << err << eom;
throw 0;
}
if(type.id()==ID_cpp_name)
{
c_qualifierst qualifiers(type);
cpp_namet cpp_name;
cpp_name.swap(type);
exprt symbol_expr=resolve(
cpp_name,
cpp_typecheck_resolvet::wantt::TYPE,
cpp_typecheck_fargst());
if(symbol_expr.id()!=ID_type)
{
error().source_location=type.source_location();
error() << "error: expected type" << eom;
throw 0;
}
type=symbol_expr.type();
assert(type.is_not_nil());
if(type.get_bool(ID_C_constant))
qualifiers.is_constant = true;
qualifiers.write(type);
}
else if(type.id()==ID_struct ||
type.id()==ID_union)
{
typecheck_compound_type(to_struct_union_type(type));
}
else if(type.id()==ID_pointer)
{
// the pointer might have a qualifier, but do subtype first
typecheck_type(type.subtype());
// Check if it is a pointer-to-member
if(type.find("to-member").is_not_nil())
{
// these can point either to data members or member functions
// of a class
typet &class_object=static_cast<typet &>(type.add("to-member"));
if(class_object.id()==ID_cpp_name)
{
assert(class_object.get_sub().back().id()=="::");
class_object.get_sub().pop_back();
}
typecheck_type(class_object);
// there may be parameters if this is a pointer to member function
if(type.subtype().id()==ID_code)
{
irept::subt ¶meters=type.subtype().add(ID_parameters).get_sub();
if(parameters.empty() ||
parameters.front().get(ID_C_base_name)!=ID_this)
{
// Add 'this' to the parameters
exprt a0(ID_parameter);
a0.set(ID_C_base_name, ID_this);
a0.type().id(ID_pointer);
a0.type().subtype() = class_object;
parameters.insert(parameters.begin(), a0);
}
}
}
}
else if(type.id()==ID_array)
{
exprt &size_expr=to_array_type(type).size();
if(size_expr.is_not_nil())
{
typecheck_expr(size_expr);
simplify(size_expr, *this);
}
typecheck_type(type.subtype());
if(type.subtype().get_bool(ID_C_constant))
type.set(ID_C_constant, true);
if(type.subtype().get_bool(ID_C_volatile))
type.set(ID_C_volatile, true);
}
else if(type.id()==ID_code)
{
code_typet &code_type=to_code_type(type);
typecheck_type(code_type.return_type());
code_typet::parameterst ¶meters=code_type.parameters();
for(auto ¶m : parameters)
{
typecheck_type(param.type());
// see if there is a default value
if(param.has_default_value())
{
typecheck_expr(param.default_value());
implicit_typecast(param.default_value(), param.type());
}
}
}
else if(type.id()==ID_template)
{
typecheck_type(type.subtype());
}
else if(type.id()==ID_c_enum)
{
typecheck_enum_type(type);
}
else if(type.id()==ID_c_enum_tag)
{
}
else if(type.id()==ID_c_bit_field)
{
typecheck_c_bit_field_type(to_c_bit_field_type(type));
}
else if(type.id()==ID_unsignedbv ||
type.id()==ID_signedbv ||
type.id()==ID_bool ||
type.id()==ID_floatbv ||
type.id()==ID_fixedbv ||
type.id()==ID_empty)
{
}
else if(type.id()==ID_symbol)
{
}
else if(type.id()==ID_constructor ||
type.id()==ID_destructor)
{
}
else if(type.id()=="cpp-cast-operator")
{
}
else if(type.id()=="cpp-template-type")
{
}
else if(type.id()==ID_typeof)
{
exprt e=static_cast<const exprt &>(type.find(ID_expr_arg));
if(e.is_nil())
{
typet tmp_type=
static_cast<const typet &>(type.find(ID_type_arg));
if(tmp_type.id()==ID_cpp_name)
{
// this may be ambiguous -- it can be either a type or
// an expression
cpp_typecheck_fargst fargs;
exprt symbol_expr=resolve(
to_cpp_name(static_cast<const irept &>(tmp_type)),
cpp_typecheck_resolvet::wantt::BOTH,
fargs);
type=symbol_expr.type();
}
else
{
typecheck_type(tmp_type);
type=tmp_type;
}
}
else
{
typecheck_expr(e);
type=e.type();
}
}
else if(type.id()==ID_decltype)
{
exprt e=static_cast<const exprt &>(type.find(ID_expr_arg));
typecheck_expr(e);
type=e.type();
}
else if(type.id()==ID_unassigned)
{
// ignore, for template parameter guessing
}
else if(type.id()==ID_template_class_instance)
{
// ok (internally generated)
}
else if(type.id()==ID_block_pointer)
{
// This is an Apple extension for lambda-like constructs.
// http://thirdcog.eu/pwcblocks/
}
else if(type.id()==ID_nullptr)
{
}
else
{
error().source_location=type.source_location();
error() << "unexpected cpp type: " << type.pretty() << eom;
throw 0;
}
assert(type.is_not_nil());
}
void cpp_typecheckt::typecheck_type(typet &type)
{
assert(type.id() != "");
assert(type.is_not_nil());
try
{
cpp_convert_plain_type(type);
}
catch(const char *error)
{
err_location(type);
str << error;
throw 0;
}
catch(const std::string &error)
{
err_location(type);
str << error;
throw 0;
}
if(type.id() == "cpp-name")
{
c_qualifierst qualifiers(type);
cpp_namet cpp_name;
cpp_name.swap(type);
exprt symbol_expr =
resolve(cpp_name, cpp_typecheck_resolvet::TYPE, cpp_typecheck_fargst());
if(symbol_expr.id() != "type")
{
err_location(type);
str << "error: expected type";
throw 0;
}
type = symbol_expr.type();
assert(type.is_not_nil());
if(type.cmt_constant())
qualifiers.is_constant = true;
qualifiers.write(type);
}
else if(type.id() == "struct" || type.id() == "union")
{
typecheck_compound_type(type);
}
else if(type.id() == "pointer")
{
// the pointer might have a qualifier, but do subtype first
typecheck_type(type.subtype());
// Check if it is a pointer-to-member
if(type.find("to-member").is_not_nil())
{
// these can point either to data members or member functions
// of a class
typet &class_object = static_cast<typet &>(type.add("to-member"));
if(class_object.id() == "cpp-name")
{
assert(class_object.get_sub().back().id() == "::");
class_object.get_sub().pop_back();
}
typecheck_type(class_object);
// there may be arguments if this is a pointer to member function
if(type.subtype().id() == "code")
{
irept::subt &args = type.subtype().add("arguments").get_sub();
if(args.empty() || args.front().cmt_base_name() != "this")
{
// Add 'this' to the arguments
exprt a0("argument");
a0.cmt_base_name("this");
a0.type().id("pointer");
a0.type().subtype() = class_object;
args.insert(args.begin(), a0);
}
}
}
// now do qualifier
if(type.find("#qualifier").is_not_nil())
{
typet &t = static_cast<typet &>(type.add("#qualifier"));
cpp_convert_plain_type(t);
c_qualifierst q(t);
q.write(type);
}
type.remove("#qualifier");
}
else if(type.id() == "array")
{
exprt &size_expr = to_array_type(type).size();
if(size_expr.is_nil())
type.id("incomplete_array");
else
typecheck_expr(size_expr);
// TODO: If is a incomplete_array, it should always
// have initializers, except for catch declaration
typecheck_type(type.subtype());
if(type.subtype().cmt_constant())
type.cmt_constant(true);
if(type.subtype().cmt_volatile())
type.set("#volatile", true);
}
else if(type.id() == "code")
{
code_typet &code_type = to_code_type(type);
typecheck_type(code_type.return_type());
code_typet::argumentst &arguments = code_type.arguments();
for(auto &argument : arguments)
{
typecheck_type(argument.type());
// see if there is a default value
if(argument.has_default_value())
{
typecheck_expr(argument.default_value());
implicit_typecast(argument.default_value(), argument.type());
}
}
}
else if(type.id() == "template")
{
typecheck_type(type.subtype());
}
else if(type.id() == "c_enum")
{
typecheck_enum_type(type);
}
else if(
type.id() == "unsignedbv" || type.id() == "signedbv" ||
type.id() == "bool" || type.id() == "floatbv" || type.id() == "fixedbv" ||
type.id() == "empty")
{
}
else if(type.id() == "symbol")
{
}
else if(type.id() == "constructor" || type.id() == "destructor")
{
}
else if(type.id() == "cpp-cast-operator")
{
}
else if(type.id() == "cpp-template-type")
{
}
else if(type.id() == "typeof")
{
exprt e = static_cast<const exprt &>(type.find("expr"));
if(e.is_nil())
{
typet tmp_type = static_cast<const typet &>(type.find("sizeof-type"));
if(tmp_type.id() == "cpp-name")
{
// this may be ambiguous -- it can be either a type or
// an expression
cpp_typecheck_fargst fargs;
exprt symbol_expr = resolve(
to_cpp_name(static_cast<const irept &>(tmp_type)),
cpp_typecheck_resolvet::BOTH,
fargs);
type = symbol_expr.type();
}
else
{
typecheck_type(tmp_type);
type = tmp_type;
}
}
else
{
typecheck_expr(e);
type = e.type();
}
}
else if(type.id() == "decltype")
{
exprt e = static_cast<const exprt &>(type.find("expr_arg"));
typecheck_expr(e);
type = e.type();
}
else if(type.id() == "unassigned")
{
// ignore, for template argument guessing
}
else if(type.id() == "ellipsis")
{
}
else
{
err_location(type);
str << "unexpected type: " << type.pretty();
throw 0;
}
assert(type.is_not_nil());
}
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;
}
}
