void c_qualifierst::write(typet &dest) const
{
if(is_constant)
dest.set(ID_C_constant, true);
else
dest.remove(ID_C_constant);
if(is_volatile)
dest.set(ID_C_volatile, true);
else
dest.remove(ID_C_volatile);
if(is_restricted)
dest.set(ID_C_restricted, true);
else
dest.remove(ID_C_restricted);
if(is_ptr32)
dest.set(ID_C_ptr32, true);
else
dest.remove(ID_C_ptr32);
if(is_ptr64)
dest.set(ID_C_ptr64, true);
else
dest.remove(ID_C_ptr64);
}
void c_qualifierst::clear(typet &dest)
{
dest.remove(ID_C_constant);
dest.remove(ID_C_volatile);
dest.remove(ID_C_restricted);
dest.remove(ID_C_ptr32);
dest.remove(ID_C_ptr64);
}
void c_qualifierst::clear(typet &dest)
{
dest.remove(ID_C_constant);
dest.remove(ID_C_volatile);
dest.remove(ID_C_restricted);
dest.remove(ID_C_ptr32);
dest.remove(ID_C_ptr64);
dest.remove(ID_C_transparent_union);
dest.remove(ID_C_noreturn);
}
void c_typecheck_baset::adjust_function_parameter(typet &type) const
{
if(type.id()==ID_array)
{
type.id(ID_pointer);
type.remove(ID_size);
type.remove(ID_C_constant);
}
else if(type.id()==ID_code)
{
// see ISO/IEC 9899:1999 page 199 clause 8
pointer_typet tmp;
tmp.subtype()=type;
type.swap(tmp);
}
else if(type.id()==ID_KnR)
{
// any KnR args without type yet?
type=signed_int_type(); // the default is integer!
}
}
void c_qualifierst::write(typet &dest) const
{
if(is_constant)
dest.set(ID_C_constant, true);
else
dest.remove(ID_C_constant);
if(is_volatile)
dest.set(ID_C_volatile, true);
else
dest.remove(ID_C_volatile);
if(is_restricted)
dest.set(ID_C_restricted, true);
else
dest.remove(ID_C_restricted);
if(is_atomic)
dest.set(ID_C_atomic, true);
else
dest.remove(ID_C_atomic);
if(is_ptr32)
dest.set(ID_C_ptr32, true);
else
dest.remove(ID_C_ptr32);
if(is_ptr64)
dest.set(ID_C_ptr64, true);
else
dest.remove(ID_C_ptr64);
if(is_transparent_union)
dest.set(ID_C_transparent_union, true);
else
dest.remove(ID_C_transparent_union);
if(is_noreturn)
dest.set(ID_C_noreturn, true);
else
dest.remove(ID_C_noreturn);
}
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_custom_type(typet &type)
{
// they all have a width
exprt size_expr=
static_cast<const exprt &>(type.find(ID_size));
typecheck_expr(size_expr);
source_locationt source_location=size_expr.source_location();
make_constant_index(size_expr);
mp_integer size_int;
if(to_integer(size_expr, size_int))
{
error().source_location=source_location;
error() << "failed to convert bit vector width to constant" << eom;
throw 0;
}
if(size_int<1)
{
error().source_location=source_location;
error() << "bit vector width invalid" << eom;
throw 0;
}
type.remove(ID_size);
type.set(ID_width, integer2string(size_int));
// depending on type, there may be a number of fractional bits
if(type.id()==ID_custom_unsignedbv)
type.id(ID_unsignedbv);
else if(type.id()==ID_custom_signedbv)
type.id(ID_signedbv);
else if(type.id()==ID_custom_fixedbv)
{
type.id(ID_fixedbv);
exprt f_expr=
static_cast<const exprt &>(type.find(ID_f));
source_locationt source_location=f_expr.find_source_location();
typecheck_expr(f_expr);
make_constant_index(f_expr);
mp_integer f_int;
if(to_integer(f_expr, f_int))
{
error().source_location=source_location;
error() << "failed to convert number of fraction bits to constant" << eom;
throw 0;
}
if(f_int<0 || f_int>size_int)
{
error().source_location=source_location;
error() << "fixedbv fraction width invalid" << eom;
throw 0;
}
type.remove(ID_f);
type.set(ID_integer_bits, integer2string(size_int-f_int));
}
else if(type.id()==ID_custom_floatbv)
{
type.id(ID_floatbv);
exprt f_expr=
static_cast<const exprt &>(type.find(ID_f));
source_locationt source_location=f_expr.find_source_location();
typecheck_expr(f_expr);
make_constant_index(f_expr);
mp_integer f_int;
if(to_integer(f_expr, f_int))
{
error().source_location=source_location;
error() << "failed to convert number of fraction bits to constant" << eom;
throw 0;
}
if(f_int<1 || f_int+1>=size_int)
{
error().source_location=source_location;
error() << "floatbv fraction width invalid" << eom;
throw 0;
}
type.remove(ID_f);
type.set(ID_f, integer2string(f_int));
}
else
assert(false);
}
void c_typecheck_baset::typecheck_c_enum_type(typet &type)
{
// These come with the declarations
// of the enum constants as operands.
exprt &as_expr=static_cast<exprt &>(static_cast<irept &>(type));
source_locationt source_location=type.source_location();
// We allow empty enums in the grammar to get better
// error messages.
if(as_expr.operands().empty())
{
error().source_location=source_location;
error() << "empty enum" << eom;
throw 0;
}
// enums start at zero;
// we also track min and max to find a nice base type
mp_integer value=0, min_value=0, max_value=0;
std::list<c_enum_typet::c_enum_membert> enum_members;
// We need to determine a width, and a signedness
// to obtain an 'underlying type'.
// We just do int, but gcc might pick smaller widths
// if the type is marked as 'packed'.
// gcc/clang may also pick a larger width. Visual Studio doesn't.
for(auto &op : as_expr.operands())
{
ansi_c_declarationt &declaration=to_ansi_c_declaration(op);
exprt &v=declaration.declarator().value();
if(v.is_not_nil()) // value given?
{
exprt tmp_v=v;
typecheck_expr(tmp_v);
add_rounding_mode(tmp_v);
simplify(tmp_v, *this);
if(tmp_v.is_true())
value=1;
else if(tmp_v.is_false())
value=0;
else if(!to_integer(tmp_v, value))
{
}
else
{
error().source_location=v.source_location();
error() << "enum is not a constant";
throw 0;
}
}
if(value<min_value)
min_value=value;
if(value>max_value)
max_value=value;
typet constant_type=
enum_constant_type(min_value, max_value);
v=from_integer(value, constant_type);
declaration.type()=constant_type;
typecheck_declaration(declaration);
irep_idt base_name=
declaration.declarator().get_base_name();
irep_idt identifier=
declaration.declarator().get_name();
// store
c_enum_typet::c_enum_membert member;
member.set_identifier(identifier);
member.set_base_name(base_name);
member.set_value(integer2string(value));
enum_members.push_back(member);
// produce value for next constant
++value;
}
// Remove these now; we add them to the
// c_enum symbol later.
as_expr.operands().clear();
bool is_packed=type.get_bool(ID_C_packed);
// tag?
if(type.find(ID_tag).is_nil())
{
// None, it's anonymous. We generate a tag.
std::string anon_identifier="#anon_enum";
for(const auto &member : enum_members)
{
anon_identifier+='$';
anon_identifier+=id2string(member.get_base_name());
anon_identifier+='=';
anon_identifier+=id2string(member.get_value());
}
if(is_packed)
anon_identifier+="#packed";
type.add(ID_tag).set(ID_identifier, anon_identifier);
}
irept &tag=type.add(ID_tag);
irep_idt base_name=tag.get(ID_C_base_name);
irep_idt identifier=tag.get(ID_identifier);
// Put into symbol table
symbolt enum_tag_symbol;
enum_tag_symbol.is_type=true;
enum_tag_symbol.type=type;
enum_tag_symbol.location=source_location;
enum_tag_symbol.is_file_local=true;
enum_tag_symbol.base_name=base_name;
enum_tag_symbol.name=identifier;
// throw in the enum members as 'body'
irept::subt &body=enum_tag_symbol.type.add(ID_body).get_sub();
for(const auto &member : enum_members)
body.push_back(member);
// We use a subtype to store the underlying type.
typet underlying_type=
enum_underlying_type(min_value, max_value, is_packed);
enum_tag_symbol.type.subtype()=underlying_type;
// is it in the symbol table already?
symbol_tablet::symbolst::iterator s_it=
symbol_table.symbols.find(identifier);
if(s_it!=symbol_table.symbols.end())
{
// Yes.
symbolt &symbol=s_it->second;
if(symbol.type.id()==ID_incomplete_c_enum)
{
// Ok, overwrite the type in the symbol table.
// This gives us the members and the subtype.
symbol.type=enum_tag_symbol.type;
}
else if(symbol.type.id()==ID_c_enum)
{
// We might already have the same anonymous enum, and this is
// simply ok. Note that the C standard treats these as
// different types.
if(!base_name.empty())
{
error().source_location=type.source_location();
error() << "redeclaration of enum tag" << eom;
throw 0;
}
}
else
{
error().source_location=source_location;
error() << "use of tag that does not match previous declaration" << eom;
throw 0;
}
}
else
{
symbolt *new_symbol;
move_symbol(enum_tag_symbol, new_symbol);
}
// We produce a c_enum_tag as the resulting type.
type.id(ID_c_enum_tag);
type.remove(ID_tag);
type.set(ID_identifier, identifier);
}