Exemple #1
0
bool unified_difft::operator()()
{
  typedef std::map<irep_idt,
                   goto_functionst::function_mapt::const_iterator>
                     function_mapt;

  function_mapt old_funcs, new_funcs;

  forall_goto_functions(it, old_goto_functions)
    old_funcs.insert(std::make_pair(it->first, it));
  forall_goto_functions(it, new_goto_functions)
    new_funcs.insert(std::make_pair(it->first, it));

  goto_programt empty;

  function_mapt::const_iterator ito=old_funcs.begin();
  for(function_mapt::const_iterator itn=new_funcs.begin();
      itn!=new_funcs.end();
      ++itn)
  {
    for( ;
        ito!=old_funcs.end() && ito->first<itn->first;
        ++ito)
      unified_diff(ito->first, ito->second->second.body, empty);

    if(ito==old_funcs.end() || itn->first<ito->first)
      unified_diff(itn->first, empty, itn->second->second.body);
    else
    {
      assert(ito->first==itn->first);
      unified_diff(
        itn->first,
        ito->second->second.body,
        itn->second->second.body);
      ++ito;
    }
  }
  for( ; ito!=old_funcs.end(); ++ito)
    unified_diff(ito->first, ito->second->second.body, empty);

  return !differences_map.empty();
}
Exemple #2
0
void show_loop_ids(
  ui_message_handlert::uit ui,
  const goto_functionst &goto_functions)
{
  switch(ui)
  {
    case ui_message_handlert::PLAIN:
    case ui_message_handlert::XML_UI:
      forall_goto_functions(it, goto_functions)
        show_loop_ids(ui, it->second.body);
      break;
    case ui_message_handlert::JSON_UI:
      json_objectt json_result;
      json_arrayt &loops=json_result["loops"].make_array();

      forall_goto_functions(it, goto_functions)
        show_loop_ids_json(ui, it->second.body, loops);

      std::cout << ",\n" << json_result;
      break;
  }
}
Exemple #3
0
void is_threadedt::compute(const goto_functionst &goto_functions)
{
  // the analysis doesn't actually use the namespace, fake one
  symbol_tablet symbol_table;
  const namespacet ns(symbol_table);

  ait<is_threaded_domaint> is_threaded_analysis;

  is_threaded_analysis(goto_functions, ns);

  forall_goto_functions(f_it, goto_functions)
    forall_goto_program_instructions(i_it, f_it->second.body)
      if(is_threaded_analysis[i_it].is_threaded)
        is_threaded_set.insert(i_it);
}
remove_function_pointerst::remove_function_pointerst(
  symbol_tablet &_symbol_table,
  bool _add_safety_assertion,
  const goto_functionst &goto_functions):
  ns(_symbol_table),
  symbol_table(_symbol_table),
  add_safety_assertion(_add_safety_assertion)
{
  compute_address_taken_in_symbols(address_taken);
  compute_address_taken_functions(goto_functions, address_taken);

  // build type map
  forall_goto_functions(f_it, goto_functions)
    type_map[f_it->first]=f_it->second.type;
}
remove_function_pointerst::remove_function_pointerst(
  message_handlert &_message_handler,
  symbol_tablet &_symbol_table,
  bool _add_safety_assertion, bool only_resolve_const_fps,
  const goto_functionst &goto_functions):
  messaget(_message_handler),
  ns(_symbol_table),
  symbol_table(_symbol_table),
  add_safety_assertion(_add_safety_assertion),
  only_resolve_const_fps(only_resolve_const_fps)
{
  compute_address_taken_in_symbols(address_taken);
  compute_address_taken_functions(goto_functions, address_taken);

  // build type map
  forall_goto_functions(f_it, goto_functions)
    type_map[f_it->first]=f_it->second.type;
}
Exemple #6
0
int preparet::get_async_modules()
{
  if(goto_functions.function_map.empty())
  {
    // see if we have a "main"

    if(context.symbols.find("main")==context.symbols.end())
    {
      error("failed to find entry point -- please provide a model");
      return 1;
    }

    status("Generating GOTO Program");

    goto_convert(
        context,
        goto_functions,
        get_message_handler());
  }

  // we no longer need any parse trees or language files
  clear_parse();

  // finally add the library
  status("Adding CPROVER library");      
  link_to_library(
      context, goto_functions, get_message_handler());

  if(cmdline.isset("show-goto-functions"))
  {
    goto_functions.output(ns, std::cout);
    return 0;
  }

  unsigned functions=goto_functions.function_map.size();
  unsigned instructions=0;
  forall_goto_functions(it, goto_functions)
    instructions+=it->second.body.instructions.size();

  status(i2string(functions)+" functions, "+
      i2string(instructions)+" instructions.");

  if(cmdline.isset("string-abstraction"))
    string_instrumentation(
        context, get_message_handler(), goto_functions);

  status("Removing function pointers");
  remove_function_pointers(ns, goto_functions, cmdline.isset("pointer-check"));

  status("Removing unused functions");
  remove_unused_functions(
      goto_functions, get_message_handler());

  // Boom requies full inlining.
  bool boom=
    !cmdline.isset("modelchecker") ||
    std::string(cmdline.getval("modelchecker"))=="boom";

  // OSWALDO
  if(cmdline.isset("full-inlining") || boom)
  {
    status("Full inlining");

    satabs_inline(
        goto_functions,
        ns,
        get_message_handler());
  }
  else
  {
    // partially inline functions
    status("Partial inlining");

    satabs_partial_inline(
        goto_functions,
        ns,
        get_message_handler());

    // we do this again, to remove all the functions that are inlined now
    remove_unused_functions(
        goto_functions, get_message_handler());

    status("Adjusting functions");
    prepare_functions(
        context,
        goto_functions,
        get_message_handler());

    // show it?
    if(cmdline.isset("show-adjusted-functions"))
    {
      goto_functions.output(ns, std::cout);
      return 0;
    }
  }

  // add loop ids
  goto_functions.compute_loop_numbers();

  add_failed_symbols(context);

  // add generic checks
  goto_check(ns, options, goto_functions);

  if(cmdline.isset("string-abstraction"))
  {
    status("String Abstraction");
    string_abstraction(
        context,
        get_message_handler(),
        goto_functions);
  }  

  goto_functions.compute_location_numbers();

  #if 0
  // obsoleted by goto_check
  if(cmdline.isset("pointer-check") ||
      cmdline.isset("show-value-sets"))
  {
    status("Pointer Analysis");
    value_set_analysist value_set_analysis(ns);
    value_set_analysis(goto_functions);

    // show it?
    if(cmdline.isset("show-value-sets"))
    {
      show_value_sets(get_ui(), goto_functions, value_set_analysis);
      return 0;
    }

    if(cmdline.isset("pointer-check"))
    {
      status("Adding Pointer Checks");

      // add pointer checks
      pointer_checks(
          goto_functions, context, options, value_set_analysis);
    }
  }
  #endif

  goto_functions.compute_location_numbers();

  // label claims
  label_claims(goto_functions);

  // set claim
  if(cmdline.isset("claim"))
    set_claims(
        goto_functions,
        cmdline.get_values("claim"));

  // reachability slice?
  if(!cmdline.isset("no-slicing"))
    reachability_slicer(goto_functions);

  // show it?

  if(cmdline.isset("show-final-program"))
  {
    goto_functions.output(ns, std::cout);
    return 0;
  }

  return -1; // proceed!
}
Exemple #7
0
int preparet::get_async_modules()
{
  if(goto_functions.function_map.empty())
  {
    // see if we have a "main"

    if(context.symbols.find("main")==context.symbols.end())
    {
      error("failed to find entry point -- please provide a model");
      return 1;
    }

    status("Generating GOTO Program");

    goto_convert(
      context,
      options,
      goto_functions,
      get_message_handler());
  }
    
  if(cmdline.isset("show-goto-functions"))
  {
    goto_functions.output(ns, std::cout);
    return 0;
  }
  
  unsigned functions=goto_functions.function_map.size();
  unsigned instructions=0;
  forall_goto_functions(it, goto_functions)
    instructions+=it->second.body.instructions.size();
  
  status(i2string(functions)+" functions, "+
         i2string(instructions)+" instructions.");
  
  if(cmdline.isset("string-abstraction"))
    string_instrumentation(
      context, get_message_handler(), goto_functions);

  status("Removing function pointers");
  remove_function_pointers(ns, goto_functions);

  status("Removing unused functions");
  remove_unused_functions(
    goto_functions, get_message_handler());

  if(cmdline.isset("full-inlining"))
  {
    status("Full inlining");

    satabs_inline(
      goto_functions,
      ns,
      get_message_handler());
  }
  else
  {
    // partially inline functions
    status("Partial inlining");

    satabs_partial_inline(
      goto_functions,
      ns,
      get_message_handler());
  
    // we do this again, to remove all the functions that are inlined now
    remove_unused_functions(
      goto_functions, get_message_handler());

    status("Adjusting functions");
    prepare_functions(
      context,
      goto_functions,
      get_message_handler());

    // show it?
    if(cmdline.isset("show-adjusted-functions"))
    {
      goto_functions.output(ns, std::cout);
      return 0;
    }
  }
  
  // add loop ids
  goto_functions.compute_loop_numbers();

  // show it?
  if(cmdline.isset("show-loops"))
  {
    show_loop_numbers(get_ui(), goto_functions);
    return 0;
  }

  add_failed_symbols(context);

  // add generic checks
  goto_check(ns, options, goto_functions);

  if(cmdline.isset("string-abstraction"))
  {
    status("String Abstraction");
    string_abstraction(
      context,
      get_message_handler(),
      goto_functions);
  }  
  
  goto_functions.compute_location_numbers();

  if(cmdline.isset("pointer-check") ||
     cmdline.isset("show-value-sets") ||
     cmdline.isset("data-race-check"))
  {
    status("Pointer Analysis");
    value_set_analysist value_set_analysis(ns);
    value_set_analysis(goto_functions);

    // show it?
    if(cmdline.isset("show-value-sets"))
    {
      show_value_sets(get_ui(), goto_functions, value_set_analysis);
      return 0;
    }

    if(cmdline.isset("pointer-check"))
    {
      status("Adding Pointer Checks");

      // add pointer checks
      pointer_checks(
        goto_functions, context, options, value_set_analysis);
    }

    if(cmdline.isset("data-race-check"))
    {
      status("Adding Data Race Checks");

      add_race_assertions(
        value_set_analysis,
        context,
        goto_functions);

      value_set_analysis.
        update(goto_functions);
    }
  }
  
  goto_functions.compute_location_numbers();

  #if 0  
  // do invariant propagation
  if(!cmdline.isset("no-invariant-sets"))
  {
    status("Invariant Propagation");
    invariant_propagation(
      goto_functions);
  }
  else
    invariant_propagation.initialize(
      goto_functions);

  if(cmdline.isset("show-invariant-sets"))
  {
    invariant_propagation.output(
      goto_functions, std::cout);
    return 0;
  }

  // simplify
  if(!cmdline.isset("no-invariant-sets"))
    invariant_propagation.simplify(
      goto_functions);
  #endif

  // set claim
  if(cmdline.isset("claim"))
    set_claims(
      goto_functions,
      cmdline.get_values("claim"));
      
  // slice
  if(!cmdline.isset("no-slicing"))
    slicer(goto_functions);

  // show it?

  if(cmdline.isset("show-final-program"))
  {
    goto_functions.output(ns, std::cout);
    return 0;
  }

  return -1; // proceed!
}
Exemple #8
0
void horn_encodingt::operator()()
{
  forall_goto_functions(f_it, goto_functions)
    translate(f_it);
}
Exemple #9
0
safety_checkert::resultt bmc_all_propertiest::operator()()
{
  status() << "Passing problem to " << solver.decision_procedure_text() << eom;

  solver.set_message_handler(get_message_handler());

  // stop the time
  absolute_timet sat_start=current_time();

  bmc.do_conversion();

  // Collect _all_ goals in `goal_map'.
  // This maps property IDs to 'goalt'
  forall_goto_functions(f_it, goto_functions)
    forall_goto_program_instructions(i_it, f_it->second.body)
      if(i_it->is_assert())
        goal_map[i_it->source_location.get_property_id()]=goalt(*i_it);

  // get the conditions for these goals from formula
  // collect all 'instances' of the properties
  for(symex_target_equationt::SSA_stepst::iterator
      it=bmc.equation.SSA_steps.begin();
      it!=bmc.equation.SSA_steps.end();
      it++)
  {
    if(it->is_assert())
    {
      irep_idt property_id;

      if(it->source.pc->is_assert())
        property_id=it->source.pc->source_location.get_property_id();
      else if(it->source.pc->is_goto())
      {
        // this is likely an unwinding assertion
        property_id=id2string(
          it->source.pc->source_location.get_function())+".unwind."+
          std::to_string(it->source.pc->loop_number);
        goal_map[property_id].description=it->comment;
      }
      else
        continue;

      goal_map[property_id].instances.push_back(it);
    }
  }

  do_before_solving();

  cover_goalst cover_goals(solver);

  cover_goals.set_message_handler(get_message_handler());
  cover_goals.register_observer(*this);

  for(const auto &g : goal_map)
  {
    // Our goal is to falsify a property, i.e., we will
    // add the negation of the property as goal.
    literalt p=!solver.convert(g.second.as_expr());
    cover_goals.add(p);
  }

  status() << "Running " << solver.decision_procedure_text() << eom;

  bool error=false;

  decision_proceduret::resultt result=cover_goals();

  if(result==decision_proceduret::resultt::D_ERROR)
  {
    error=true;
    for(auto &g : goal_map)
      if(g.second.status==goalt::statust::UNKNOWN)
        g.second.status=goalt::statust::ERROR;
  }
  else
  {
    for(auto &g : goal_map)
      if(g.second.status==goalt::statust::UNKNOWN)
        g.second.status=goalt::statust::SUCCESS;
  }

  // output runtime

  {
    absolute_timet sat_stop=current_time();
    status() << "Runtime decision procedure: "
             << (sat_stop-sat_start) << "s" << eom;
  }

  // report
  report(cover_goals);

  if(error)
    return safety_checkert::resultt::ERROR;

  bool safe=(cover_goals.number_covered()==0);

  if(safe)
    bmc.report_success(); // legacy, might go away
  else
    bmc.report_failure(); // legacy, might go away

  return safe?safety_checkert::resultt::SAFE:safety_checkert::resultt::UNSAFE;
}