void label_properties(goto_functionst &goto_functions) { std::map<irep_idt, unsigned> property_counters; for(goto_functionst::function_mapt::iterator it=goto_functions.function_map.begin(); it!=goto_functions.function_map.end(); it++) if(!it->second.is_inlined()) label_properties(it->second.body, property_counters); }
void show_defs( const indext &index, const optionst &options, std::ostream &out, message_handlert &message_handler) { for(indext::file_to_functiont::const_iterator file_it=index.file_to_function.begin(); file_it!=index.file_to_function.end(); file_it++) { // read the file goto_modelt model; read_goto_binary(index.full_path(file_it->first), model, message_handler); // add the properties goto_check(options, model); model.goto_functions.update(); label_properties(model.goto_functions); const namespacet ns(model.symbol_table); const std::set<irep_idt> &functions=file_it->second; // now do all functions from model for(std::set<irep_idt>::const_iterator fkt_it=functions.begin(); fkt_it!=functions.end(); fkt_it++) { const irep_idt &id=*fkt_it; const goto_functionst::function_mapt::const_iterator m_it= model.goto_functions.function_map.find(id); assert(m_it!=model.goto_functions.function_map.end()); const goto_functionst::goto_functiont *index_fkt= &m_it->second; out << ">>>> Function " << id << " in " << file_it->first << std::endl; show_defs(*index_fkt, ns, out); out << std::endl; } } }
void show_properties( const indext &index, const optionst &options, std::ostream &out, message_handlert &message_handler) { for(indext::file_to_functiont::const_iterator file_it=index.file_to_function.begin(); file_it!=index.file_to_function.end(); file_it++) { // read the file goto_modelt model; read_goto_binary(index.full_path(file_it->first), model, message_handler); // add the properties goto_check(options, model); model.goto_functions.update(); label_properties(model.goto_functions); show_properties(model, ui_message_handlert::PLAIN); } }
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 }
void label_properties(goto_programt &goto_program) { std::map<irep_idt, unsigned> property_counters; label_properties(goto_program, property_counters); }
void label_properties(goto_modelt &goto_model) { label_properties(goto_model.goto_functions); }
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 }
int clobber_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); // // 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; // do instrumentation try { const namespacet ns(symbol_table); std::ofstream out("simulator.c"); if(!out) throw std::string("failed to create file simulator.c"); dump_c(goto_functions, true, ns, out); status() << "instrumentation complete; compile and execute simulator.c" << eom; return 0; } 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 }
int cbmc_parse_optionst::doit() { if(cmdline.isset("version")) { std::cout << CBMC_VERSION << std::endl; return 0; } // // command line options // optionst options; get_command_line_options(options); eval_verbosity(); // // Print a banner // status() << "CBMC version " CBMC_VERSION " " << sizeof(void *)*8 << "-bit " << config.this_architecture() << " " << config.this_operating_system() << eom; // // Unwinding of transition systems is done by hw-cbmc. // if(cmdline.isset("module") || cmdline.isset("gen-interface")) { error() << "This version of CBMC has no support for " " hardware modules. Please use hw-cbmc." << eom; return 1; } register_languages(); if(cmdline.isset("test-preprocessor")) return test_c_preprocessor(ui_message_handler)?8:0; if(cmdline.isset("preprocess")) { preprocessing(); return 0; } goto_functionst goto_functions; // get solver cbmc_solverst cbmc_solvers(options, symbol_table, ui_message_handler); cbmc_solvers.set_ui(get_ui()); std::unique_ptr<cbmc_solverst::solvert> cbmc_solver; try { cbmc_solver=cbmc_solvers.get_solver(); } catch(const char *error_msg) { error() << error_msg << eom; return 1; } prop_convt &prop_conv=cbmc_solver->prop_conv(); bmct bmc(options, symbol_table, ui_message_handler, prop_conv); int get_goto_program_ret= get_goto_program(options, bmc, goto_functions); if(get_goto_program_ret!=-1) return get_goto_program_ret; label_properties(goto_functions); if(cmdline.isset("show-claims") || // will go away cmdline.isset("show-properties")) // use this one { const namespacet ns(symbol_table); show_properties(ns, get_ui(), goto_functions); return 0; } if(cmdline.isset("show-reachable-properties")) // may replace --show-properties { const namespacet ns(symbol_table); // Entry point will have been set before and function pointers removed status() << "Removing Unused Functions" << eom; remove_unused_functions(goto_functions, ui_message_handler); show_properties(ns, get_ui(), goto_functions); return 0; } if(set_properties(goto_functions)) return 7; if(cmdline.isset("danger")) return run_danger(options, result(), symbol_table, goto_functions); if(cmdline.isset("safety")) return run_safety(options, result(), symbol_table, goto_functions); // do actual BMC return do_bmc(bmc, goto_functions); }
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); }