void datat::read(const xmlt &xml)
{
for(xmlt::elementst::const_iterator
it=xml.elements.begin();
it!=xml.elements.end();
it++)
{
if(it->name=="property")
{
propertyt property;
for(xmlt::elementst::const_iterator
e_it=it->elements.begin();
e_it!=it->elements.end();
e_it++)
{
if(e_it->name=="file")
property.file=e_it->data;
else if(e_it->name=="line")
property.line=unsafe_string2unsigned(e_it->data);
else if(e_it->name=="category")
property.category=e_it->data;
else if(e_it->name=="message")
property.message=e_it->data;
}
properties.push_back(property);
}
else if(it->name=="description")
{
description=it->data;
}
}
}
void cvc_dect::read_assert(std::istream &in, std::string &line)
{
// strip ASSERT
line=std::string(line, strlen("ASSERT "), std::string::npos);
if(line=="")
return;
// bit-vector
if(line[0]=='(')
{
// get identifier
std::string::size_type pos=
line.find(' ');
std::string identifier=std::string(line, 1, pos-1);
// get value
if(!std::getline(in, line))
return;
// skip spaces
pos=0;
while(pos<line.size() && line[pos]==' ') pos++;
// get final ")"
std::string::size_type pos2=line.rfind(')');
if(pos2==std::string::npos)
return;
std::string value=std::string(line, pos, pos2-pos);
#if 0
std::cout << ">" << identifier << "< = >" << value << "<";
std::cout << std::endl;
#endif
}
else
{
// boolean
bool value=true;
if(has_prefix(line, "NOT "))
{
line=std::string(line, strlen("NOT "), std::string::npos);
value=false;
}
if(line=="")
return;
if(line[0]=='l')
{
unsigned number=unsafe_string2unsigned(line.substr(1));
assert(number<no_boolean_variables);
assert(no_boolean_variables==boolean_assignment.size());
boolean_assignment[number]=value;
}
}
}
void preprocessor_line(
const char *text,
parsert &parser)
{
const char *ptr=text;
std::string line_number;
// skip WS
while(*ptr==' ' || *ptr=='\t') ptr++;
// skip #
if(*ptr!='#')
return;
ptr++;
// skip WS
while(*ptr==' ' || *ptr=='\t') ptr++;
// skip "line"
if(*ptr=='l')
{
while(*ptr!=0 && *ptr!=' ' && *ptr!='\t') ptr++;
}
// skip WS
while(*ptr==' ' || *ptr=='\t') ptr++;
// get line number
while(isdigit(*ptr))
{
line_number+=*ptr;
ptr++;
}
// skip until "
while(*ptr!='\n' && *ptr!='"') ptr++;
parser.set_line_no(unsafe_string2unsigned(line_number));
// skip "
if(*ptr!='"')
return;
ptr++;
std::string file_name_tmp;
// get file name
while(*ptr!='\n' && *ptr!='"')
{
file_name_tmp+=*ptr;
ptr++;
}
std::string file_name_tmp2=unescape_string(file_name_tmp);
parser.set_file(file_name_tmp2);
}
void bv_spect::from_type(const typet &type)
{
if(type.id()==ID_unsignedbv)
is_signed=false;
else if(type.id()==ID_signedbv)
is_signed=true;
else
assert(0);
width=unsafe_string2unsigned(type.get_string(ID_width));
}
void goto_instrument_parse_optionst::eval_verbosity()
{
unsigned int v=8;
if(cmdline.isset("verbosity"))
{
v=unsafe_string2unsigned(cmdline.get_value("verbosity"));
if(v>10) v=10;
}
ui_message_handler.set_verbosity(v);
}
void cbmc_parse_optionst::eval_verbosity()
{
// this is our default verbosity
unsigned int v=messaget::M_STATISTICS;
if(cmdline.isset("verbosity"))
{
v=unsafe_string2unsigned(cmdline.get_value("verbosity"));
if(v>10) v=10;
}
ui_message_handler.set_verbosity(v);
}
void goto_fence_inserter_parse_optionst::set_verbosity()
{
unsigned int v=8; // default
if(cmdline.isset("verbosity"))
{
v=unsafe_string2unsigned(cmdline.get_value("verbosity"));
if(v>10)
v=10;
}
ui_message_handler.set_verbosity(v);
}
inline static unsigned bv_width(
const typet &type,
const namespacet &ns)
{
if(type.id()==ID_c_enum_tag)
{
const typet &t=ns.follow_tag(to_c_enum_tag_type(type));
assert(t.id()==ID_c_enum);
return bv_width(t.subtype(), ns);
}
return unsafe_string2unsigned(type.get_string(ID_width));
}
unsigned get_max(
const std::string &prefix,
const symbol_tablet::symbolst &symbols)
{
unsigned max_nr=0;
forall_symbols(it, symbols)
if(has_prefix(id2string(it->first), prefix))
max_nr=
std::max(unsafe_string2unsigned(
id2string(it->first).substr(prefix.size())),
max_nr);
return max_nr;
}
void convert(
const irept &irep,
goto_programt::instructiont &instruction)
{
instruction.code=static_cast<const codet &>(irep.find(ID_code));
instruction.function = irep.find(ID_function).id();
instruction.source_location = static_cast<const source_locationt &>(irep.find(ID_location));
instruction.type = static_cast<goto_program_instruction_typet>(
unsafe_string2unsigned(irep.find(ID_type).id_string()));
instruction.guard = static_cast<const exprt&>(irep.find(ID_guard));
// don't touch the targets, the goto_programt conversion does that
const irept &lbls=irep.find(ID_labels);
const irept::subt &lsubs=lbls.get_sub();
for (irept::subt::const_iterator it=lsubs.begin();
it!=lsubs.end();
it++)
{
instruction.labels.push_back(it->id());
}
}
void convert( const irept &irep, goto_programt &program )
{
assert(irep.id()=="goto-program");
program.instructions.clear();
std::list< std::list<unsigned> > number_targets_list;
// convert instructions back
const irept::subt &subs = irep.get_sub();
for (irept::subt::const_iterator it=subs.begin();
it!=subs.end();
it++)
{
program.instructions.push_back(goto_programt::instructiont());
convert(*it, program.instructions.back());
number_targets_list.push_back(std::list<unsigned>());
const irept &targets=it->find(ID_targets);
const irept::subt &tsubs=targets.get_sub();
for (irept::subt::const_iterator tit=tsubs.begin();
tit!=tsubs.end();
tit++)
{
number_targets_list.back().push_back(
unsafe_string2unsigned(tit->id_string()));
}
}
program.compute_location_numbers();
// resolve targets
std::list< std::list<unsigned> >::iterator nit=
number_targets_list.begin();
for(goto_programt::instructionst::iterator lit=
program.instructions.begin();
lit!=program.instructions.end() && nit!=number_targets_list.end();
lit++, nit++)
{
for (std::list<unsigned>::iterator tit=nit->begin();
tit!=nit->end();
tit++)
{
goto_programt::targett fit=program.instructions.begin();
for(;fit!=program.instructions.end();fit++)
{
if (fit->location_number==*tit)
{
lit->targets.push_back(fit);
break;
}
}
if (fit==program.instructions.end())
{
std::cout << "Warning: could not resolve target link "
<< "during irep->goto_program translation." << std::endl;
throw 0;
}
}
}
program.update();
}
void goto_fence_inserter_parse_optionst::instrument_goto_program(
goto_functionst &goto_functions)
{
optionst options;
// unwind loops
if(cmdline.isset("unwind"))
{
status() << "Unwinding loops" << eom;
options.set_option("unwind", cmdline.get_value("unwind"));
}
// we add the library, as some analyses benefit
status() << "Adding CPROVER library" << eom;
link_to_library(symbol_table, goto_functions, ui_message_handler);
namespacet ns(symbol_table);
if( cmdline.isset("mm")
|| cmdline.isset("all-shared")
|| cmdline.isset("volatile")
|| cmdline.isset("pensieve")
|| cmdline.isset("naive")
|| cmdline.isset("all-shared-aeg") )
{
if(cmdline.isset("remove-function-pointers"))
{
status() << "remove soundly function pointers" << eom;
remove_function_pointers(symbol_table, goto_functions,
cmdline.isset("pointer-check"));
}
if(cmdline.isset("async"))
{
status() << "Replace pthread_creates by __CPROVER_ASYNC_0:" << eom;
replace_async(ns, goto_functions);
goto_functions.update();
}
// do partial inlining
status() << "Partial Inlining" << eom;
goto_partial_inline(goto_functions, ns, ui_message_handler);
if(cmdline.isset("const-function-pointer-propagation"))
{
/* propagate const pointers to functions */
status() << "Propagate Constant Function Pointers" << eom;
propagate_const_function_pointers(symbol_table, goto_functions,
get_message_handler());
}
// goto_functions.output(ns, std::cout);
// return;
#if 0
status() << "Function Pointer Removal" << eom;
remove_function_pointers(symbol_table, goto_functions,
cmdline.isset("pointer-check"));
#endif
#if 0
// do partial inlining
status() << "Partial Inlining" << eom;
goto_partial_inline(goto_functions, ns, ui_message_handler);
#endif
status() << "Pointer Analysis" << eom;
#ifdef POINTER_ANALYSIS_FI
value_set_analysis_fit value_set_analysis(ns);
#else
value_set_analysist value_set_analysis(ns);
#endif
#ifndef LOCAL_MAY
value_set_analysis(goto_functions);
#endif
status() << "Removing asm code" << eom;
remove_asm(symbol_table, goto_functions);
goto_functions.update();
if(cmdline.isset("all-shared"))
{
status() << "Shared variables accesses detection" << eom;
fence_all_shared(get_message_handler(), value_set_analysis, symbol_table,
goto_functions);
// simple analysis, coupled with script to insert;
// does not transform the goto-binary
return;
}
if(cmdline.isset("all-shared-aeg"))
{
status() << "Shared variables accesses detection (CF)" << eom;
fence_all_shared_aeg(get_message_handler(), value_set_analysis,
symbol_table, goto_functions);
// simple analysis, coupled with script to insert;
// does not transform the goto-binary
return;
}
else if(cmdline.isset("volatile"))
{
status() << "Detection of variables declared volatile" << eom;
fence_volatile(get_message_handler(), value_set_analysis, symbol_table,
goto_functions);
// simple analysis, coupled with script to insert;
// does not transform the goto-binary
return;
}
else if(cmdline.isset("pensieve") || cmdline.isset("naive"))
{
status() << "Delay-set analysis" << eom;
const unsigned unwind_loops=
cmdline.isset("unwind") ?
unsafe_string2unsigned(cmdline.get_value("unwind")) : 0;
const unsigned max_po_trans=
cmdline.isset("max-po-trans") ?
unsafe_string2unsigned(cmdline.get_value("max-po-trans")) : 0;
fence_pensieve(
value_set_analysis,
symbol_table,
goto_functions,
unwind_loops,
max_po_trans,
!cmdline.isset("no-po-rendering"),
cmdline.isset("render-cluster-file"),
cmdline.isset("render-cluster-function"),
cmdline.isset("naive"),
get_message_handler());
// simple analysis, coupled with script to insert;
// does not transform the goto-binary
return;
}
else if(cmdline.isset("mm"))
{
std::string mm=cmdline.get_value("mm");
memory_modelt model;
status() << "Fence detection for " << mm
<< " via critical cycles and ILP" << eom;
// strategy of instrumentation
instrumentation_strategyt inst_strategy;
if(cmdline.isset("one-event-per-cycle"))
inst_strategy=one_event_per_cycle;
else if(cmdline.isset("minimum-interference"))
inst_strategy=min_interference;
else if(cmdline.isset("read-first"))
inst_strategy=read_first;
else if(cmdline.isset("write-first"))
inst_strategy=write_first;
else if(cmdline.isset("my-events"))
inst_strategy=my_events;
else
/* default: instruments all unsafe pairs */
inst_strategy=all;
const unsigned unwind_loops =
cmdline.isset("unwind") ?
unsafe_string2unsigned(cmdline.get_value("unwind")) : 0;
const unsigned max_var =
cmdline.isset("max-var") ?
unsafe_string2unsigned(cmdline.get_value("max-var")) : 0;
const unsigned max_po_trans =
cmdline.isset("max-po-trans") ?
unsafe_string2unsigned(cmdline.get_value("max-po-trans")) : 0;
if(mm=="tso")
{
status() << "Adding weak memory (TSO) Instrumentation" << eom;
model=TSO;
}
else if(mm=="pso")
{
status() << "Adding weak memory (PSO) Instrumentation" << eom;
model=PSO;
}
else if(mm=="rmo")
{
status() << "Adding weak memory (RMO) Instrumentation" << eom;
model=RMO;
}
else if(mm=="power")
{
status() << "Adding weak memory (Power) Instrumentation" << eom;
model=Power;
}
else
{
status/*error*/() << "Unknown weak memory model" << eom;
model=Unknown;
}
/* inference mode */
infer_modet infer_mode=INFER;
if(cmdline.isset("userdef"))
infer_mode=USER_DEF;
loop_strategyt loops=arrays_only;
if(cmdline.isset("force-loop-duplication"))
loops=all_loops;
if(cmdline.isset("no-loop-duplication"))
loops=no_loop;
/*if(model!=Unknown)*/
fence_weak_memory(
model,
value_set_analysis,
symbol_table,
goto_functions,
cmdline.isset("scc"),
inst_strategy,
unwind_loops,
!cmdline.isset("cfg-kill"),
cmdline.isset("no-dependencies"),
loops,
max_var,
max_po_trans,
!cmdline.isset("no-po-rendering"),
cmdline.isset("render-cluster-file"),
cmdline.isset("render-cluster-function"),
cmdline.isset("cav11"),
cmdline.isset("hide-internals"),
cmdline.isset("print-graph"),
infer_mode,
get_message_handler(),
cmdline.isset("ignore-arrays"));
}
}
// add failed symbols
add_failed_symbols(symbol_table);
// recalculate numbers, etc.
goto_functions.update();
// add loop ids
goto_functions.compute_loop_numbers();
// label the assertions
label_properties(goto_functions);
}
literalt boolbvt::convert_overflow(const exprt &expr)
{
const exprt::operandst &operands=expr.operands();
if(expr.id()==ID_overflow_plus ||
expr.id()==ID_overflow_minus)
{
if(operands.size()!=2)
throw "operator "+expr.id_string()+" takes two operands";
const bvt &bv0=convert_bv(operands[0]);
const bvt &bv1=convert_bv(operands[1]);
if(bv0.size()!=bv1.size())
return SUB::convert_rest(expr);
bv_utilst::representationt rep=
expr.op0().type().id()==ID_signedbv?bv_utilst::representationt::SIGNED:
bv_utilst::representationt::UNSIGNED;
return expr.id()==ID_overflow_minus?
bv_utils.overflow_sub(bv0, bv1, rep):
bv_utils.overflow_add(bv0, bv1, rep);
}
else if(expr.id()==ID_overflow_mult)
{
if(operands.size()!=2)
throw "operator "+expr.id_string()+" takes two operands";
if(operands[0].type().id()!=ID_unsignedbv &&
operands[0].type().id()!=ID_signedbv)
return SUB::convert_rest(expr);
bvt bv0=convert_bv(operands[0]);
bvt bv1=convert_bv(operands[1]);
if(bv0.size()!=bv1.size())
throw "operand size mismatch on overflow-*";
bv_utilst::representationt rep=
operands[0].type().id()==ID_signedbv?bv_utilst::representationt::SIGNED:
bv_utilst::representationt::UNSIGNED;
if(operands[0].type()!=operands[1].type())
throw "operand type mismatch on overflow-*";
assert(bv0.size()==bv1.size());
std::size_t old_size=bv0.size();
std::size_t new_size=old_size*2;
// sign/zero extension
bv0=bv_utils.extension(bv0, new_size, rep);
bv1=bv_utils.extension(bv1, new_size, rep);
bvt result=bv_utils.multiplier(bv0, bv1, rep);
if(rep==bv_utilst::representationt::UNSIGNED)
{
bvt bv_overflow;
bv_overflow.reserve(old_size);
// get top result bits
for(std::size_t i=old_size; i<result.size(); i++)
bv_overflow.push_back(result[i]);
return prop.lor(bv_overflow);
}
else
{
bvt bv_overflow;
bv_overflow.reserve(old_size);
// get top result bits, plus one more
assert(old_size!=0);
for(std::size_t i=old_size-1; i<result.size(); i++)
bv_overflow.push_back(result[i]);
// these need to be either all 1's or all 0's
literalt all_one=prop.land(bv_overflow);
literalt all_zero=!prop.lor(bv_overflow);
return !prop.lor(all_one, all_zero);
}
}
else if(expr.id()==ID_overflow_unary_minus)
{
if(operands.size()!=1)
throw "operator "+expr.id_string()+" takes one operand";
const bvt &bv=convert_bv(operands[0]);
return bv_utils.overflow_negate(bv);
}
else if(has_prefix(expr.id_string(), "overflow-typecast-"))
{
std::size_t bits=unsafe_string2unsigned(id2string(expr.id()).substr(18));
const exprt::operandst &operands=expr.operands();
if(operands.size()!=1)
throw "operator "+expr.id_string()+" takes one operand";
const exprt &op=operands[0];
const bvt &bv=convert_bv(op);
if(bits>=bv.size() || bits==0)
throw "overflow-typecast got wrong number of bits";
// signed or unsigned?
if(op.type().id()==ID_signedbv)
{
bvt tmp_bv;
for(std::size_t i=bits; i<bv.size(); i++)
tmp_bv.push_back(prop.lxor(bv[bits-1], bv[i]));
return prop.lor(tmp_bv);
}
else
{
bvt tmp_bv;
for(std::size_t i=bits; i<bv.size(); i++)
tmp_bv.push_back(bv[i]);
return prop.lor(tmp_bv);
}
}
return SUB::convert_rest(expr);
}
int symex_parseoptionst::doit()
{
if(cmdline.isset("version"))
{
std::cout << CBMC_VERSION << std::endl;
return 0;
}
register_language(new_ansi_c_language);
register_language(new_cpp_language);
//
// command line options
//
optionst options;
get_command_line_options(options);
eval_verbosity();
goto_functionst goto_functions;
if(get_goto_program(options, goto_functions))
return 6;
label_properties(goto_functions);
if(cmdline.isset("show-properties"))
{
const namespacet ns(symbol_table);
show_properties(ns, get_ui(), goto_functions);
return 0;
}
if(set_properties(goto_functions))
return 7;
if(cmdline.isset("show-locs"))
{
const namespacet ns(symbol_table);
locst locs(ns);
locs.build(goto_functions);
locs.output(std::cout);
return 0;
}
// do actual Symex
try
{
const namespacet ns(symbol_table);
path_searcht path_search(ns);
path_search.set_message_handler(get_message_handler());
path_search.set_verbosity(get_verbosity());
if(cmdline.isset("depth"))
path_search.depth_limit=unsafe_string2unsigned(cmdline.getval("depth"));
if(cmdline.isset("context-bound"))
path_search.context_bound=unsafe_string2unsigned(cmdline.getval("context-bound"));
if(cmdline.isset("unwind"))
path_search.unwind_limit=unsafe_string2unsigned(cmdline.getval("unwind"));
if(cmdline.isset("show-vcc"))
{
path_search.show_vcc=true;
path_search(goto_functions);
return 0;
}
// do actual symex
switch(path_search(goto_functions))
{
case safety_checkert::SAFE:
report_properties(path_search.property_map);
report_success();
return 0;
case safety_checkert::UNSAFE:
report_properties(path_search.property_map);
report_failure();
return 10;
default:
return 8;
}
}
catch(const std::string error_msg)
{
error() << error_msg << messaget::eom;
return 8;
}
catch(const char *error_msg)
{
error() << error_msg << messaget::eom;
return 8;
}
#if 0
// let's log some more statistics
debug() << "Memory consumption:" << messaget::endl;
memory_info(debug());
debug() << eom;
#endif
}
bool ms_cl_modet::doit()
{
if(cmdline.isset('?') ||
cmdline.isset("help"))
{
help();
return false;
}
unsigned int verbosity=1;
compilet compiler(cmdline);
#if 0
bool act_as_ld=
has_prefix(base_name, "link") ||
has_prefix(base_name, "goto-link");
#endif
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
compiler.ui_message_handler.set_verbosity(verbosity);
ui_message_handler.set_verbosity(verbosity);
debug() << "Visual Studio mode" << eom;
// get configuration
config.set(cmdline);
config.ansi_c.mode=configt::ansi_ct::flavourt::MODE_VISUAL_STUDIO_C_CPP;
compiler.object_file_extension="obj";
// determine actions to be undertaken
if(cmdline.isset('E') || cmdline.isset('P'))
compiler.mode=compilet::PREPROCESS_ONLY;
else if(cmdline.isset('c'))
compiler.mode=compilet::COMPILE_ONLY;
else
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
compiler.echo_file_name=true;
if(cmdline.isset("Fo"))
{
compiler.output_file_object=cmdline.get_value("Fo");
// this could be a directory
if(is_directory(compiler.output_file_object))
{
if(cmdline.args.size()>=1)
compiler.output_file_object+=get_base_name(cmdline.args[0])+".obj";
}
}
if(cmdline.isset("Fe"))
{
compiler.output_file_executable=cmdline.get_value("Fe");
// this could be a directory
if(is_directory(compiler.output_file_executable))
{
if(cmdline.args.size()>=1)
compiler.output_file_executable+=get_base_name(cmdline.args[0])+".exe";
}
}
else
{
// We need at least one argument.
// CL uses the first file name it gets!
if(cmdline.args.size()>=1)
compiler.output_file_executable=get_base_name(cmdline.args[0])+".exe";
}
if(cmdline.isset('J'))
config.ansi_c.char_is_unsigned=true;
if(verbosity>8)
{
std::list<std::string>::iterator it;
std::cout << "Defines:\n";
for(it=config.ansi_c.defines.begin();
it!=config.ansi_c.defines.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Undefines:\n";
for(it=config.ansi_c.undefines.begin();
it!=config.ansi_c.undefines.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Preprocessor Options:\n";
for(it=config.ansi_c.preprocessor_options.begin();
it!=config.ansi_c.preprocessor_options.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Include Paths:\n";
for(it=config.ansi_c.include_paths.begin();
it!=config.ansi_c.include_paths.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Library Paths:\n";
for(it=compiler.library_paths.begin();
it!=compiler.library_paths.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Output file (object): " << compiler.output_file_object << std::endl;
std::cout << "Output file (executable): " << compiler.output_file_executable << std::endl;
}
// Parse input program, convert to goto program, write output
return compiler.doit();
}
/// does it.
int cw_modet::doit()
{
if(cmdline.isset('?') || cmdline.isset("help"))
{
help();
return EX_OK;
}
unsigned int verbosity=1;
compilet compiler(cmdline, message_handler, cmdline.isset("Werror"));
#if 0
bool act_as_ld=
has_prefix(base_name, "ld") ||
has_prefix(base_name, "goto-ld") ||
has_prefix(base_name, "link") ||
has_prefix(base_name, "goto-link");
#endif
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
compiler.set_message_handler(get_message_handler());
message_handler.set_verbosity(verbosity);
debug() << "CodeWarrior mode" << eom;
// get configuration
config.set(cmdline);
config.ansi_c.mode=configt::ansi_ct::flavourt::CODEWARRIOR;
compiler.object_file_extension="o";
// determine actions to be taken
if(cmdline.isset('E'))
compiler.mode=compilet::PREPROCESS_ONLY;
else if(cmdline.isset('c') || cmdline.isset('S'))
compiler.mode=compilet::COMPILE_ONLY;
else
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
if(cmdline.isset('U'))
config.ansi_c.undefines=cmdline.get_values('U');
if(cmdline.isset("undef"))
config.ansi_c.preprocessor_options.push_back("-undef");
if(cmdline.isset("nostdinc"))
config.ansi_c.preprocessor_options.push_back("-nostdinc");
if(cmdline.isset('L'))
compiler.library_paths=cmdline.get_values('L');
// Don't add the system paths!
if(cmdline.isset('l'))
compiler.libraries=cmdline.get_values('l');
if(cmdline.isset('o'))
{
// given gcc -o file1 -o file2,
// gcc will output to file2, not file1
compiler.output_file_object=cmdline.get_values('o').back();
compiler.output_file_executable=cmdline.get_values('o').back();
}
else
{
compiler.output_file_object="";
compiler.output_file_executable="a.out";
}
if(cmdline.isset("Wp,"))
{
const std::list<std::string> &values=
cmdline.get_values("Wp,");
for(std::list<std::string>::const_iterator
it=values.begin();
it!=values.end();
it++)
config.ansi_c.preprocessor_options.push_back("-Wp,"+*it);
}
if(cmdline.isset("isystem"))
{
const std::list<std::string> &values=
cmdline.get_values("isystem");
for(std::list<std::string>::const_iterator
it=values.begin();
it!=values.end();
it++)
config.ansi_c.preprocessor_options.push_back("-isystem "+*it);
}
if(verbosity>8)
{
std::list<std::string>::iterator it;
std::cout << "Defines:\n";
for(it=config.ansi_c.defines.begin();
it!=config.ansi_c.defines.end();
it++)
{
std::cout << " " << (*it) << '\n';
}
std::cout << "Undefines:\n";
for(it=config.ansi_c.undefines.begin();
it!=config.ansi_c.undefines.end();
it++)
{
std::cout << " " << (*it) << '\n';
}
std::cout << "Preprocessor Options:\n";
for(it=config.ansi_c.preprocessor_options.begin();
it!=config.ansi_c.preprocessor_options.end();
it++)
{
std::cout << " " << (*it) << '\n';
}
std::cout << "Include Paths:\n";
for(it=config.ansi_c.include_paths.begin();
it!=config.ansi_c.include_paths.end();
it++)
{
std::cout << " " << (*it) << '\n';
}
std::cout << "Library Paths:\n";
for(it=compiler.library_paths.begin();
it!=compiler.library_paths.end();
it++)
{
std::cout << " " << (*it) << '\n';
}
std::cout << "Output file (object): "
<< compiler.output_file_object << '\n';
std::cout << "Output file (executable): "
<< compiler.output_file_executable << '\n';
}
// Parse input program, convert to goto program, write output
return compiler.doit() ? EX_USAGE : EX_OK;
}
unsigned fixedbv_typet::get_integer_bits() const
{
const irep_idt integer_bits=get(ID_integer_bits);
assert(integer_bits!=irep_idt());
return unsafe_string2unsigned(id2string(integer_bits));
}
unsigned floatbv_typet::get_f() const
{
const irep_idt &f=get(ID_f);
assert(f!=irep_idt());
return unsafe_string2unsigned(id2string(f));
}
/// does it.
int gcc_modet::doit()
{
if(cmdline.isset('?') ||
cmdline.isset("help"))
{
help();
return EX_OK;
}
native_tool_name=
act_as_ld ?
linker_name(cmdline, base_name) :
compiler_name(cmdline, base_name);
unsigned int verbosity=1;
bool act_as_bcc=
base_name=="bcc" ||
base_name.find("goto-bcc")!=std::string::npos;
if((cmdline.isset('v') && cmdline.have_infile_arg()) ||
(cmdline.isset("version") && !produce_hybrid_binary))
{
// "-v" a) prints the version and b) increases verbosity.
// Compilation continues, don't exit!
if(act_as_ld)
std::cout << "GNU ld version 2.16.91 20050610 (goto-cc " CBMC_VERSION
<< ")\n";
else if(act_as_bcc)
std::cout << "bcc: version 0.16.17 (goto-cc " CBMC_VERSION ")\n";
else
std::cout << "gcc version 3.4.4 (goto-cc " CBMC_VERSION ")\n";
}
if(cmdline.isset("version"))
{
if(produce_hybrid_binary)
return run_gcc();
std::cout << '\n' <<
"Copyright (C) 2006-2014 Daniel Kroening, Christoph Wintersteiger\n" <<
"CBMC version: " CBMC_VERSION << '\n' <<
"Architecture: " << config.this_architecture() << '\n' <<
"OS: " << config.this_operating_system() << '\n';
return EX_OK; // Exit!
}
if(cmdline.isset("dumpversion"))
{
if(produce_hybrid_binary)
return run_gcc();
std::cout << "3.4.4\n";
return EX_OK;
}
if(cmdline.isset("Wall") || cmdline.isset("Wextra"))
verbosity=2;
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
gcc_message_handler.set_verbosity(verbosity);
if(act_as_ld)
{
if(produce_hybrid_binary)
debug() << "LD mode (hybrid)" << eom;
else
debug() << "LD mode" << eom;
}
else if(act_as_bcc)
{
if(produce_hybrid_binary)
debug() << "BCC mode (hybrid)" << eom;
else
debug() << "BCC mode" << eom;
}
else
{
if(produce_hybrid_binary)
debug() << "GCC mode (hybrid)" << eom;
else
debug() << "GCC mode" << eom;
}
// In gcc mode, we have just pass on to gcc to handle the following:
// * if -M or -MM is given, we do dependencies only
// * preprocessing (-E)
// * no input files given
if(act_as_ld)
{
}
else if(cmdline.isset('M') ||
cmdline.isset("MM") ||
cmdline.isset('E') ||
!cmdline.have_infile_arg())
return run_gcc(); // exit!
// get configuration
config.set(cmdline);
// Intel-specific
// in GCC, m16 is 32-bit (!), as documented here:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59672
if(cmdline.isset("m16") ||
cmdline.isset("m32") || cmdline.isset("mx32"))
{
config.ansi_c.arch="i386";
config.ansi_c.set_arch_spec_i386();
}
else if(cmdline.isset("m64"))
{
config.ansi_c.arch="x86_64";
config.ansi_c.set_arch_spec_x86_64();
}
// ARM-specific
if(cmdline.isset("mbig-endian") || cmdline.isset("mbig"))
config.ansi_c.endianness=configt::ansi_ct::endiannesst::IS_BIG_ENDIAN;
else if(cmdline.isset("little-endian") || cmdline.isset("mlittle"))
config.ansi_c.endianness=configt::ansi_ct::endiannesst::IS_LITTLE_ENDIAN;
if(cmdline.isset("mthumb") || cmdline.isset("mthumb-interwork"))
config.ansi_c.set_arch_spec_arm("armhf");
// -mcpu sets both the arch and tune, but should only be used if
// neither -march nor -mtune are passed on the command line.
std::string target_cpu=
cmdline.isset("march") ? cmdline.get_value("march") :
cmdline.isset("mtune") ? cmdline.get_value("mtune") :
cmdline.isset("mcpu") ? cmdline.get_value("mcpu") : "";
if(target_cpu!="")
{
// Work out what CPROVER architecture we should target.
for(auto &pair : arch_map)
for(auto &processor : pair.second)
if(processor==target_cpu)
{
if(pair.first.find("mips")==std::string::npos)
config.set_arch(pair.first);
else
{
// Targeting a MIPS processor. MIPS is special; we also need
// to know the endianness. -EB (big-endian) is the default.
if(cmdline.isset("EL"))
{
if(pair.first=="mips32o")
config.set_arch("mipsel");
else if(pair.first=="mips32n")
config.set_arch("mipsn32el");
else
config.set_arch("mips64el");
}
else
{
if(pair.first=="mips32o")
config.set_arch("mips");
else if(pair.first=="mips32n")
config.set_arch("mipsn32");
else
config.set_arch("mips64");
}
}
}
}
// -fshort-wchar makes wchar_t "short unsigned int"
if(cmdline.isset("fshort-wchar"))
{
config.ansi_c.wchar_t_width=config.ansi_c.short_int_width;
config.ansi_c.wchar_t_is_unsigned=true;
}
// -fsingle-precision-constant makes floating-point constants "float"
// instead of double
if(cmdline.isset("-fsingle-precision-constant"))
config.ansi_c.single_precision_constant=true;
// -fshort-double makes double the same as float
if(cmdline.isset("fshort-double"))
config.ansi_c.double_width=config.ansi_c.single_width;
// determine actions to be undertaken
compilet compiler(cmdline,
gcc_message_handler,
cmdline.isset("Werror") &&
cmdline.isset("Wextra") &&
!cmdline.isset("Wno-error"));
if(act_as_ld)
compiler.mode=compilet::LINK_LIBRARY;
else if(cmdline.isset('S'))
compiler.mode=compilet::ASSEMBLE_ONLY;
else if(cmdline.isset('c'))
compiler.mode=compilet::COMPILE_ONLY;
else if(cmdline.isset('E'))
{
compiler.mode=compilet::PREPROCESS_ONLY;
UNREACHABLE;
}
else if(cmdline.isset("shared") ||
cmdline.isset('r')) // really not well documented
compiler.mode=compilet::COMPILE_LINK;
else
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
switch(compiler.mode)
{
case compilet::LINK_LIBRARY:
debug() << "Linking a library only" << eom; break;
case compilet::COMPILE_ONLY:
debug() << "Compiling only" << eom; break;
case compilet::ASSEMBLE_ONLY:
debug() << "Assembling only" << eom; break;
case compilet::PREPROCESS_ONLY:
debug() << "Preprocessing only" << eom; break;
case compilet::COMPILE_LINK:
debug() << "Compiling and linking a library" << eom; break;
case compilet::COMPILE_LINK_EXECUTABLE:
debug() << "Compiling and linking an executable" << eom; break;
}
if(cmdline.isset("i386-win32") ||
cmdline.isset("winx64"))
{
// We may wish to reconsider the below.
config.ansi_c.mode=configt::ansi_ct::flavourt::VISUAL_STUDIO;
debug() << "Enabling Visual Studio syntax" << eom;
}
else if(config.this_operating_system()=="macos")
config.ansi_c.mode=configt::ansi_ct::flavourt::APPLE;
else
config.ansi_c.mode=configt::ansi_ct::flavourt::GCC;
if(compiler.mode==compilet::ASSEMBLE_ONLY)
compiler.object_file_extension="s";
else
compiler.object_file_extension="o";
if(cmdline.isset("std"))
{
std::string std_string=cmdline.get_value("std");
if(std_string=="gnu89" || std_string=="c89")
config.ansi_c.set_c89();
if(std_string=="gnu99" || std_string=="c99" || std_string=="iso9899:1999" ||
std_string=="gnu9x" || std_string=="c9x" || std_string=="iso9899:199x")
config.ansi_c.set_c99();
if(std_string=="gnu11" || std_string=="c11" ||
std_string=="gnu1x" || std_string=="c1x")
config.ansi_c.set_c11();
if(std_string=="c++11" || std_string=="c++1x" ||
std_string=="gnu++11" || std_string=="gnu++1x" ||
std_string=="c++1y" ||
std_string=="gnu++1y")
config.cpp.set_cpp11();
if(std_string=="gnu++14" || std_string=="c++14")
config.cpp.set_cpp14();
}
// gcc's default is 32 bits for wchar_t
if(cmdline.isset("short-wchar"))
config.ansi_c.wchar_t_width=16;
// gcc's default is 64 bits for double
if(cmdline.isset("short-double"))
config.ansi_c.double_width=32;
// gcc's default is signed chars on most architectures
if(cmdline.isset("funsigned-char"))
config.ansi_c.char_is_unsigned=true;
if(cmdline.isset("fsigned-char"))
config.ansi_c.char_is_unsigned=false;
if(cmdline.isset('U'))
config.ansi_c.undefines=cmdline.get_values('U');
if(cmdline.isset("undef"))
config.ansi_c.preprocessor_options.push_back("-undef");
if(cmdline.isset("nostdinc"))
config.ansi_c.preprocessor_options.push_back("-nostdinc");
if(cmdline.isset('L'))
compiler.library_paths=cmdline.get_values('L');
// Don't add the system paths!
if(cmdline.isset('l'))
compiler.libraries=cmdline.get_values('l');
if(cmdline.isset("static"))
compiler.libraries.push_back("c");
if(cmdline.isset("pthread"))
compiler.libraries.push_back("pthread");
if(cmdline.isset('o'))
{
// given gcc -o file1 -o file2,
// gcc will output to file2, not file1
compiler.output_file_object=cmdline.get_values('o').back();
compiler.output_file_executable=cmdline.get_values('o').back();
}
else
{
compiler.output_file_object="";
compiler.output_file_executable="a.out";
}
// We now iterate over any input files
temp_dirt temp_dir("goto-cc-XXXXXX");
{
std::string language;
for(goto_cc_cmdlinet::parsed_argvt::iterator
arg_it=cmdline.parsed_argv.begin();
arg_it!=cmdline.parsed_argv.end();
arg_it++)
{
if(arg_it->is_infile_name)
{
// do any preprocessing needed
if(language=="cpp-output" || language=="c++-cpp-output")
{
compiler.add_input_file(arg_it->arg);
}
else if(language=="c" || language=="c++" ||
(language=="" && needs_preprocessing(arg_it->arg)))
{
std::string new_suffix;
if(language=="c")
new_suffix=".i";
else if(language=="c++")
new_suffix=".ii";
else
new_suffix=has_suffix(arg_it->arg, ".c")?".i":".ii";
std::string new_name=
get_base_name(arg_it->arg, true)+new_suffix;
std::string dest=temp_dir(new_name);
int exit_code=
preprocess(language, arg_it->arg, dest, act_as_bcc);
if(exit_code!=0)
{
error() << "preprocessing has failed" << eom;
return exit_code;
}
compiler.add_input_file(dest);
}
else
compiler.add_input_file(arg_it->arg);
}
else if(arg_it->arg=="-x")
{
arg_it++;
if(arg_it!=cmdline.parsed_argv.end())
{
language=arg_it->arg;
if(language=="none")
language="";
}
}
else if(has_prefix(arg_it->arg, "-x"))
{
language=std::string(arg_it->arg, 2, std::string::npos);
if(language=="none")
language="";
}
}
}
// Revert to gcc in case there is no source to compile
// and no binary to link.
if(compiler.source_files.empty() &&
compiler.object_files.empty())
return run_gcc(); // exit!
if(compiler.mode==compilet::ASSEMBLE_ONLY)
return asm_output(act_as_bcc, compiler.source_files);
// do all the rest
if(compiler.doit())
return 1; // GCC exit code for all kinds of errors
// We can generate hybrid ELF and Mach-O binaries
// containing both executable machine code and the goto-binary.
if(produce_hybrid_binary && !act_as_bcc)
return gcc_hybrid_binary();
return EX_OK;
}
/// does it.
int as_modet::doit()
{
if(cmdline.isset('?') ||
cmdline.isset("help"))
{
help();
return EX_OK;
}
unsigned int verbosity=1;
bool act_as_as86=
base_name=="as86" ||
base_name.find("goto-as86")!=std::string::npos;
if((cmdline.isset('v') && act_as_as86) ||
cmdline.isset("version"))
{
if(act_as_as86)
status() << "as86 version: 0.16.17 (goto-cc " CBMC_VERSION ")"
<< eom;
else
status() << "GNU assembler version 2.20.51.0.7 20100318"
<< " (goto-cc " CBMC_VERSION ")" << eom;
status() << '\n' <<
"Copyright (C) 2006-2014 Daniel Kroening, Christoph Wintersteiger\n" <<
"CBMC version: " CBMC_VERSION << '\n' <<
"Architecture: " << config.this_architecture() << '\n' <<
"OS: " << config.this_operating_system() << eom;
return EX_OK; // Exit!
}
if(cmdline.isset("w-") || cmdline.isset("warn"))
verbosity=2;
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
message_handler.set_verbosity(verbosity);
if(act_as_as86)
{
if(produce_hybrid_binary)
debug() << "AS86 mode (hybrid)" << eom;
else
debug() << "AS86 mode" << eom;
}
else
{
if(produce_hybrid_binary)
debug() << "AS mode (hybrid)" << eom;
else
debug() << "AS mode" << eom;
}
// get configuration
config.set(cmdline);
// determine actions to be undertaken
compilet compiler(cmdline, message_handler, cmdline.isset("fatal-warnings"));
if(cmdline.isset('b')) // as86 only
{
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
debug() << "Compiling and linking an executable" << eom;
}
else
{
compiler.mode=compilet::COMPILE_LINK;
debug() << "Compiling and linking a library" << eom;
}
config.ansi_c.mode=configt::ansi_ct::flavourt::GCC;
compiler.object_file_extension="o";
if(cmdline.isset('o'))
{
compiler.output_file_object=cmdline.get_value('o');
compiler.output_file_executable=cmdline.get_value('o');
}
else if(cmdline.isset('b')) // as86 only
{
compiler.output_file_object=cmdline.get_value('b');
compiler.output_file_executable=cmdline.get_value('b');
}
else
{
compiler.output_file_object="a.out";
compiler.output_file_executable="a.out";
}
// We now iterate over any input files
temp_dirt temp_dir("goto-cc-XXXXXX");
for(goto_cc_cmdlinet::parsed_argvt::iterator
arg_it=cmdline.parsed_argv.begin();
arg_it!=cmdline.parsed_argv.end();
arg_it++)
{
if(!arg_it->is_infile_name)
continue;
// extract the preprocessed source from the file
std::string infile=arg_it->arg=="-"?cmdline.stdin_file:arg_it->arg;
std::ifstream is(infile);
if(!is.is_open())
{
error() << "Failed to open input source " << infile << eom;
return 1;
}
// there could be multiple source files in case GCC's --combine
// was used
unsigned outputs=0;
std::string line;
std::ofstream os;
std::string dest;
const std::string comment2=act_as_as86 ? "::" : "##";
// search for comment2 GOTO-CC
// strip comment2 from all subsequent lines
while(std::getline(is, line))
{
if(line==comment2+" GOTO-CC")
{
if(outputs>0)
{
assert(!dest.empty());
compiler.add_input_file(dest);
os.close();
}
++outputs;
std::string new_name=
get_base_name(infile, true)+"_"+
std::to_string(outputs)+".i";
dest=temp_dir(new_name);
os.open(dest);
if(!os.is_open())
{
error() << "Failed to tmp output file " << dest << eom;
return 1;
}
continue;
}
else if(outputs==0)
continue;
if(line.size()>2)
os << line.substr(2) << '\n';
}
if(outputs>0)
{
assert(!dest.empty());
compiler.add_input_file(dest);
}
else
warning() << "No GOTO-CC section found in " << arg_it->arg << eom;
}
// Revert to as in case there is no source to compile
if(compiler.source_files.empty())
return run_as(); // exit!
// do all the rest
if(compiler.doit())
return 1; // GCC exit code for all kinds of errors
// We can generate hybrid ELF and Mach-O binaries
// containing both executable machine code and the goto-binary.
if(produce_hybrid_binary)
return as_hybrid_binary();
return EX_OK;
}
int symex_parse_optionst::doit()
{
if(cmdline.isset("version"))
{
std::cout << CBMC_VERSION << std::endl;
return 0;
}
register_language(new_ansi_c_language);
register_language(new_cpp_language);
register_language(new_java_bytecode_language);
//
// command line options
//
optionst options;
get_command_line_options(options);
eval_verbosity();
goto_model.set_message_handler(get_message_handler());
if(goto_model(cmdline.args))
return 6;
if(process_goto_program(options))
return 6;
label_properties(goto_model);
if(cmdline.isset("show-properties"))
{
show_properties(goto_model, get_ui());
return 0;
}
if(set_properties())
return 7;
if(cmdline.isset("show-locs"))
{
const namespacet ns(goto_model.symbol_table);
locst locs(ns);
locs.build(goto_model.goto_functions);
locs.output(std::cout);
return 0;
}
// do actual Symex
try
{
const namespacet ns(goto_model.symbol_table);
path_searcht path_search(ns);
path_search.set_message_handler(get_message_handler());
if(cmdline.isset("depth"))
path_search.set_depth_limit(unsafe_string2unsigned(cmdline.get_value("depth")));
if(cmdline.isset("context-bound"))
path_search.set_context_bound(unsafe_string2unsigned(cmdline.get_value("context-bound")));
if(cmdline.isset("branch-bound"))
path_search.set_branch_bound(unsafe_string2unsigned(cmdline.get_value("branch-bound")));
if(cmdline.isset("unwind"))
path_search.set_unwind_limit(unsafe_string2unsigned(cmdline.get_value("unwind")));
if(cmdline.isset("dfs"))
path_search.set_dfs();
if(cmdline.isset("bfs"))
path_search.set_bfs();
if(cmdline.isset("locs"))
path_search.set_locs();
if(cmdline.isset("show-vcc"))
{
path_search.show_vcc=true;
path_search(goto_model.goto_functions);
return 0;
}
path_search.eager_infeasibility=
cmdline.isset("eager-infeasibility");
if(cmdline.isset("cover"))
{
// test-suite generation
path_search(goto_model.goto_functions);
report_cover(path_search.property_map);
return 0;
}
else
{
// do actual symex, for assertion checking
switch(path_search(goto_model.goto_functions))
{
case safety_checkert::SAFE:
report_properties(path_search.property_map);
report_success();
return 0;
case safety_checkert::UNSAFE:
report_properties(path_search.property_map);
report_failure();
return 10;
default:
return 8;
}
}
}
catch(const std::string error_msg)
{
error() << error_msg << messaget::eom;
return 8;
}
catch(const char *error_msg)
{
error() << error_msg << messaget::eom;
return 8;
}
#if 0
// let's log some more statistics
debug() << "Memory consumption:" << messaget::endl;
memory_info(debug());
debug() << eom;
#endif
}
unsigned int irept::get_unsigned_int(const irep_namet &name) const
{
return unsafe_string2unsigned(get_string(name));
}
void dplib_convt::convert_dplib_expr(const exprt &expr)
{
if(expr.id()==ID_symbol)
{
convert_identifier(expr.get_string(ID_identifier));
}
else if(expr.id()==ID_nondet_symbol)
{
convert_identifier("nondet$"+expr.get_string(ID_identifier));
}
else if(expr.id()==ID_typecast)
{
assert(expr.operands().size()==1);
const exprt &op=expr.op0();
if(expr.type().id()==ID_bool)
{
if(op.type().id()==ID_signedbv ||
op.type().id()==ID_unsignedbv ||
op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
dplib_prop.out << "/=";
convert_dplib_expr(gen_zero(op.type()));
}
else
{
throw "TODO typecast1 "+op.type().id_string()+" -> bool";
}
}
else if(expr.type().id()==ID_signedbv ||
expr.type().id()==ID_unsignedbv)
{
unsigned to_width=unsafe_string2unsigned(id2string(expr.type().get(ID_width)));
if(op.type().id()==ID_signedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "SX(";
convert_dplib_expr(op);
dplib_prop.out << ", " << to_width << ")";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_unsignedbv)
{
unsigned from_width=unsafe_string2unsigned(id2string(op.type().get(ID_width)));
if(from_width==to_width)
convert_dplib_expr(op);
else if(from_width<to_width)
{
dplib_prop.out << "(0bin";
for(unsigned i=from_width; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << "))";
}
else
{
dplib_prop.out << "(";
convert_dplib_expr(op);
dplib_prop.out << ")[" << (to_width-1) << ":0]";
}
}
else if(op.type().id()==ID_bool)
{
if(to_width>1)
{
dplib_prop.out << "(0bin";
for(unsigned i=1; i<to_width; i++)
dplib_prop.out << "0";
dplib_prop.out << " @ ";
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF)";
}
else
{
dplib_prop.out << "IF ";
convert_dplib_expr(op);
dplib_prop.out << " THEN 0bin1 ELSE 0bin0 ENDIF";
}
}
else
{
throw "TODO typecast2 "+op.type().id_string()+
" -> "+expr.type().id_string();
}
}
else if(expr.type().id()==ID_pointer)
{
if(op.type().id()==ID_pointer)
{
convert_dplib_expr(op);
}
else
throw "TODO typecast3 "+op.type().id_string()+" -> pointer";
}
else
throw "TODO typecast4 ? -> "+expr.type().id_string();
}
else if(expr.id()==ID_struct)
{
dplib_prop.out << "(# ";
const struct_typet &struct_type=to_struct_type(expr.type());
const struct_typet::componentst &components=
struct_type.components();
assert(components.size()==expr.operands().size());
unsigned i=0;
for(struct_typet::componentst::const_iterator
it=components.begin();
it!=components.end();
it++, i++)
{
if(i!=0) dplib_prop.out << ", ";
dplib_prop.out << it->get(ID_name);
dplib_prop.out << ":=";
convert_dplib_expr(expr.operands()[i]);
}
dplib_prop.out << " #)";
}
else if(expr.id()==ID_constant)
{
if(expr.type().id()==ID_unsignedbv ||
expr.type().id()==ID_signedbv ||
expr.type().id()==ID_bv)
{
dplib_prop.out << "0bin" << expr.get(ID_value);
}
else if(expr.type().id()==ID_pointer)
{
const irep_idt &value=expr.get(ID_value);
if(value=="NULL")
{
dplib_prop.out << "(# object:="
<< pointer_logic.get_null_object()
<< ", offset:="
<< bin_zero(config.ansi_c.pointer_width) << " #)";
}
else
throw "unknown pointer constant: "+id2string(value);
}
else if(expr.type().id()==ID_bool)
{
if(expr.is_true())
dplib_prop.out << "TRUE";
else if(expr.is_false())
dplib_prop.out << "FALSE";
else
throw "unknown boolean constant";
}
else if(expr.type().id()==ID_array)
{
dplib_prop.out << "ARRAY (i: " << array_index_type() << "):";
assert(!expr.operands().empty());
unsigned i=0;
forall_operands(it, expr)
{
if(i==0)
dplib_prop.out << "\n IF ";
else
dplib_prop.out << "\n ELSIF ";
dplib_prop.out << "i=" << array_index(i) << " THEN ";
convert_array_value(*it);
i++;
}
dplib_prop.out << "\n ELSE ";
convert_dplib_expr(expr.op0());
dplib_prop.out << "\n ENDIF";
}
else if(expr.type().id()==ID_integer ||