Exemplo n.º 1
0
literalt boolbvt::convert_equality(const equal_exprt &expr)
{
  if(!base_type_eq(expr.lhs().type(), expr.rhs().type(), ns))
  {
    std::cout << "######### lhs: " << expr.lhs().pretty() << '\n';
    std::cout << "######### rhs: " << expr.rhs().pretty() << '\n';
    throw "equality without matching types";
  }

  // see if it is an unbounded array
  if(is_unbounded_array(expr.lhs().type()))
  {
    // flatten byte_update/byte_extract operators if needed

    if(has_byte_operator(expr))
    {
      exprt tmp=flatten_byte_operators(expr, ns);
      return record_array_equality(to_equal_expr(tmp));
    }

    return record_array_equality(expr);
  }

  const bvt &bv0=convert_bv(expr.lhs());
  const bvt &bv1=convert_bv(expr.rhs());

  if(bv0.size()!=bv1.size())
  {
    std::cerr << "lhs: " << expr.lhs().pretty() << '\n';
    std::cerr << "lhs size: " << bv0.size() << '\n';
    std::cerr << "rhs: " << expr.rhs().pretty() << '\n';
    std::cerr << "rhs size: " << bv1.size() << '\n';
    throw "unexpected size mismatch on equality";
  }

  if(bv0.empty())
  {
    // An empty bit-vector comparison. It's not clear
    // what this is meant to say.
    return prop.new_variable();
  }

  return bv_utils.equal(bv0, bv1);
}
Exemplo n.º 2
0
void
acdl_worklist_orderedt::dec_update (const local_SSAt &SSA, const acdl_domaint::meet_irreduciblet &stmt, const exprt& assertion)
{
  // **********************************************************************
  // Initialization Strategy: Guarantees top-down and bottom-up propagation
  // Decision -- Top
  // Leaf node  -- Middle
  // Rest       -- Bottom
  // **********************************************************************
  typedef std::list<acdl_domaint::statementt> assert_worklistt;
  assert_worklistt assert_worklist;
  typedef std::list<acdl_domaint::statementt> predecs_worklistt;
  predecs_worklistt predecs_worklist;
  typedef std::list<acdl_domaint::statementt> leaf_worklistt;
  leaf_worklistt leaf_worklist;
  typedef std::list<acdl_domaint::statementt> inter_worklistt;
  inter_worklistt inter_worklist;
  assert_listt assert_list;
  if (SSA.nodes.empty ())
    return;

  push_into_list(assert_worklist, stmt);
  // Now compute the transitive dependencies
  // compute fixpoint mu X. assert_nodes u predecessor(X)
  while(!assert_worklist.empty() > 0) {
    // collect all the leaf nodes
    const acdl_domaint::statementt statement=pop_from_list(assert_worklist);

    // select vars in the present statement
    acdl_domaint::varst vars;
    select_vars (statement, vars);
    // compute the predecessors
    update(SSA, vars, predecs_worklist, statement, assertion);

    // std::list<acdl_domaint::statementt>::iterator
    //  iterassert=std::find(assert_list.begin(), assert_list.end(), statement);

    for(std::list<acdl_domaint::statementt>::const_iterator
      it=predecs_worklist.begin(); it!=predecs_worklist.end(); ++it) {
      std::list<acdl_domaint::statementt>::iterator finditer=
                  std::find(worklist.begin(), worklist.end(), *it);

      // This is required to prevent inserting
      // individual assertions to the worklist
      std::list<acdl_domaint::statementt>::iterator iterassert=
        std::find(assert_list.begin(), assert_list.end(), *it);
      if(finditer==worklist.end() && iterassert==assert_list.end())
      {
        // never seen this statement before
        push(*it);
        push_into_assertion_list(assert_worklist, *it);
        // push into map
        live_var_list.clear();
        push_into_map(*it, live_var_list);
      }
    }
  }
#ifdef DEBUG
   std::cout << "The content of the sliced but unordered worklist is as follows: " << std::endl;
    for(std::list<acdl_domaint::statementt>::const_iterator it=worklist.begin(); it!=worklist.end(); ++it) {
    std::cout << "Sliced Unordered Worklist Element::" << from_expr(SSA.ns, "", *it) << std::endl;
    }
#endif

  // order the leaf nodes right after all assertions

  // order the leaf nodes right after all assertions
  for(std::list<acdl_domaint::statementt>::const_iterator
    it=worklist.begin(); it!=worklist.end(); ++it)
  {
    if(it->id()==ID_equal) {
     exprt expr_rhs=to_equal_expr(*it).rhs();
     if(expr_rhs.id()==ID_constant || expr_rhs.is_true() || expr_rhs.is_false()) {
       push_into_list(leaf_worklist, *it);
     }
     else if(expr_rhs.type().id()!=ID_constant) {
       push_into_list(inter_worklist, *it);
     }
    }
    else {
       push_into_list(inter_worklist, *it);
    }
  }


 #if 0

  for(std::list<acdl_domaint::statementt>::const_iterator
    it=worklist.begin(); it!=worklist.end(); ++it)
  {
    if(it->id()==ID_equal) {
     exprt expr_rhs=to_equal_expr(*it).rhs();
     if(expr_rhs.type().id()==ID_constant) {
       std::cout << "The type is " << expr_rhs.type().id() << std::endl;
       std::cout << "pushing equalities into leaf" << std::endl;
       push_into_list(leaf_worklist, *it);
     }
     else if(expr_rhs.type().id()!=ID_constant) {
       std::cout << "pushing equalities into inter" << std::endl;
       push_into_list(inter_worklist, *it);
     }
    }
    else {
       std::cout << "pushing constraint" << std::endl;
       push_into_list(inter_worklist, *it);
    }
  }
#endif
    #if 0
    // Do we need to separately treat ID_constraint ?
    if(it->id()==ID_equal) {
     exprt expr_rhs=to_equal_expr(*it).rhs();
     if(expr_rhs.id()==ID_constant)
       push_into_list(leaf_worklist, *it);
    // We do not push nondet elements in to the worklist
    /* std::string str("nondet");
     std::string rhs_str=id2string(expr_rhs.get(ID_identifier));
    std::size_t found=rhs_str.find(str);
    // push the nondet statement in rhs
    if(found!=std::string::npos)
      push_into_list(leaf_worklist, *it);
    */
     // exprt expr_rhs=expr.rhs();
     // select vars in the present statement
     acdl_domaint::varst vars_rhs;
     select_vars (expr_rhs, vars_rhs);

     for(std::list<acdl_domaint::statementt>::const_iterator it1=worklist.begin(); it1!=worklist.end(); ++it1)
      {
        if(*it==*it1) continue;
        else {
         /*if(!(check_statement(*it1, vars_rhs))) {
           // *it is a leaf node
           // push_into_worklist(leaf_worklist, *it);
        }
         // this is an intermediate node, not leaf
         else {*/
           push_into_list(inter_worklist, *it);
        }
      }
    }
  }
Exemplo n.º 3
0
void
acdl_worklist_orderedt::initialize (const local_SSAt &SSA, const exprt &assertion, const exprt& additional_constraint)
{

  // **********************************************************************
  // Initialization Strategy: Guarantees top-down and bottom-up propagation
  // Assertions -- Top
  // Leaf node  -- Middle
  // Rest       -- Bottom
  // **********************************************************************
  typedef std::list<acdl_domaint::statementt> assert_worklistt;
  assert_worklistt assert_worklist;
  typedef std::list<acdl_domaint::statementt> predecs_worklistt;
  predecs_worklistt predecs_worklist;
  typedef std::list<acdl_domaint::statementt> leaf_worklistt;
  leaf_worklistt leaf_worklist;
  typedef std::list<acdl_domaint::statementt> inter_worklistt;
  inter_worklistt inter_worklist;
  assert_listt assert_list;

  #if 0
  if (SSA.nodes.empty ())
    return;
  #endif
  if(statements.empty()) return;

  // insert the assertions like (!(a1 && a2 && a3)) on to the worklist
  #if 0
  and_exprt::operandst and_expr;
  for (local_SSAt::nodest::const_iterator n_it=SSA.nodes.begin ();
      n_it!=SSA.nodes.end (); n_it++)
  {
    for (local_SSAt::nodet::assertionst::const_iterator a_it=
        n_it->assertions.begin (); a_it!=n_it->assertions.end (); a_it++)
    {
       push_into_list(assert_worklist, *a_it);
       and_expr.push_back(*a_it);
       push_into_assertion_list(assert_list, not_exprt(*a_it));
       // push into worklist_vars
       acdl_domaint::varst avars;
       find_symbols(*a_it, avars);
       worklist_vars.insert(avars.begin(), avars.end());
    }
  }
  #endif
  push_into_list(assert_worklist, assertion);
  push_into_assertion_list(assert_list, not_exprt(assertion));
  acdl_domaint::varst avars;
  find_symbols(assertion, avars);
  worklist_vars.insert(avars.begin(), avars.end());

  // Now compute the transitive dependencies
  // compute fixpoint mu X. assert_nodes u predecessor(X)
  while(!assert_worklist.empty() > 0) {
#ifdef DEBUG
    std::cout << "Populating the worklist" << std::endl;
#endif
    // collect all the leaf nodes
    const acdl_domaint::statementt statement=pop_from_list(assert_worklist);

    // select vars in the present statement
    acdl_domaint::varst vars;
    select_vars (statement, vars);
    // compute the predecessors
    update(SSA, vars, predecs_worklist, statement, assertion);

    // std::list<acdl_domaint::statementt>::iterator
    //  iterassert=std::find(assert_list.begin(), assert_list.end(), statement);

    for(std::list<acdl_domaint::statementt>::const_iterator
      it=predecs_worklist.begin(); it!=predecs_worklist.end(); ++it) {
      std::list<acdl_domaint::statementt>::iterator finditer=
                  std::find(worklist.begin(), worklist.end(), *it);

      // This is required to prevent inserting
      // individual assertions to the worklist
      std::list<acdl_domaint::statementt>::iterator iterassert=
        std::find(assert_list.begin(), assert_list.end(), *it);
      if(finditer==worklist.end() && iterassert==assert_list.end())
      {
        // never seen this statement before
        push(*it);
        push_into_assertion_list(assert_worklist, *it);
      }
    }
  }


#ifdef DEBUG
   std::cout << "The content of the sliced but unordered worklist is as follows: " << std::endl;
    for(std::list<acdl_domaint::statementt>::const_iterator it=worklist.begin(); it!=worklist.end(); ++it) {
    std::cout << "Sliced Unordered Worklist Element::" << from_expr(SSA.ns, "", *it) << std::endl;
    }
#endif

  // order the leaf nodes right after all assertions
  for(std::list<acdl_domaint::statementt>::const_iterator
    it=worklist.begin(); it!=worklist.end(); ++it)
  {
    if(it->id()==ID_equal) {
     exprt expr_rhs=to_equal_expr(*it).rhs();
     if(expr_rhs.id()==ID_constant || expr_rhs.is_true() || expr_rhs.is_false()) {
       push_into_list(leaf_worklist, *it);
     }
     else if(expr_rhs.type().id()!=ID_constant) {
       push_into_list(inter_worklist, *it);
     }
    }
    else {
       push_into_list(inter_worklist, *it);
    }
  }

#if 0
  // order the leaf nodes right after all assertions
  for(std::list<acdl_domaint::statementt>::const_iterator
    it=worklist.begin(); it!=worklist.end(); ++it)
  {
    // Do we need to separately treat ID_constraint ?
    if(it->id()==ID_equal) {
     exprt expr_rhs=to_equal_expr(*it).rhs();
     if(expr_rhs.id()==ID_constant)
       push_into_list(leaf_worklist, *it);
    // We do not push nondet elements in to the worklist
    /* std::string str("nondet");
     std::string rhs_str=id2string(expr_rhs.get(ID_identifier));
    std::size_t found=rhs_str.find(str);
    // push the nondet statement in rhs
    if(found!=std::string::npos)
      push_into_list(leaf_worklist, *it);
    */
     // exprt expr_rhs=expr.rhs();
     // select vars in the present statement
     acdl_domaint::varst vars_rhs;
     select_vars (expr_rhs, vars_rhs);

     for(std::list<acdl_domaint::statementt>::const_iterator it1=worklist.begin(); it1!=worklist.end(); ++it1)
      {
        if(*it==*it1) continue;
        /*else {
         if(!(check_statement(*it1, vars_rhs))) {
           // *it is a leaf node
           // push_into_worklist(leaf_worklist, *it);
        }*/
         // this is an intermediate node, not leaf
         else {
           // pop the element from the list
           // const acdl_domaint::statementt statement=pop_from_worklist(worklist);
           push_into_list(inter_worklist, *it);
         }
      }
    }
  }
#endif

#ifdef DEBUG
    for(std::list<acdl_domaint::statementt>::const_iterator it=leaf_worklist.begin(); it!=leaf_worklist.end(); ++it) {
    std::cout << "Leaf Element::" << from_expr(SSA.ns, "", *it) << std::endl;
    }
    for(std::list<acdl_domaint::statementt>::const_iterator it=inter_worklist.begin(); it!=inter_worklist.end(); ++it) {
    std::cout << "Intermediate Worklist Element::" << from_expr(SSA.ns, "", *it) << std::endl;
    }
#endif
  // Now prepare the final worklist
  worklist.clear();

#if 0
  // insert assertions
  // Push the negation of the assertions into the worklist
  unsigned int size=and_expr.size();
  exprt::operandst::const_iterator it=and_expr.begin();
  if(size==1) {
    exprt::operandst::const_iterator it=and_expr.begin();
#ifdef DEBUG
    std::cout << "First single assertion push: " << *it << std::endl;
#endif
    exprt exp=*it;
    // push this into worklist at the end as TOP element
    not_exprt not_exp(exp);
    worklist.push_back(not_exp);
  }
  else {
    and_exprt final_and;
    std::swap(final_and.operands(), and_expr);
    not_exprt not_exp(final_and);
#ifdef DEBUG
    // push this into worklist at the end as TOP element
    std::cout << "First push: " << not_exp.pretty() << std::endl;
#endif
    worklist.push_back(not_exp);
  }
#endif
  // push the assertion and additional constriant
  // in to the worklist
  worklist.push_back(not_exprt(assertion));
  if(additional_constraint!=true_exprt())
   worklist.push_back(additional_constraint);

  acdl_domaint::varst var_leaf;
  // insert leaf nodes
  while(!leaf_worklist.empty() > 0) {
    const acdl_domaint::statementt statement=pop_from_list(leaf_worklist);
    push_into_list (worklist, statement);
    acdl_domaint::varst lvars;
    find_symbols(statement, lvars);
    var_leaf.insert(lvars.begin(), lvars.end());
  }

  // insert intermediate nodes
  while(!inter_worklist.empty() > 0) {
    const acdl_domaint::statementt statement=pop_from_list(inter_worklist);
    push_into_list (worklist, statement);
    // push into worklist_vars
    acdl_domaint::varst avars;
    find_symbols(statement, avars);
    // do not insert any leaf variables
    for(acdl_domaint::varst::const_iterator it=avars.begin(); it!=avars.end(); ++it) {
     if(var_leaf.find(*it)==var_leaf.end())
       worklist_vars.insert(*it);
    }
  }

#ifdef DEBUG
   std::cout << "The content of the ordered worklist is as follows: " << std::endl;
    for(std::list<acdl_domaint::statementt>::const_iterator
      it=worklist.begin(); it!=worklist.end(); ++it)
    std::cout << "Worklist Element::" << from_expr(SSA.ns, "", *it) << std::endl;
#endif


#if 0
  // **********************************************
  // Initialization Strategy: Add only assertions
  // **********************************************
  if (SSA.nodes.empty ())
    return;

  // insert the assertions like (!(a1 && a2 && a3)) on to the worklist
  and_exprt::operandst and_expr;
  for (local_SSAt::nodest::const_iterator n_it=SSA.nodes.begin ();
      n_it!=SSA.nodes.end (); n_it++)
  {
    for (local_SSAt::nodet::assertionst::const_iterator a_it=
        n_it->assertions.begin (); a_it!=n_it->assertions.end (); a_it++)
    {
       and_expr.push_back(*a_it);
    }
  }
  unsigned int size=and_expr.size();
#ifdef DEBUG
  std::cout << "The number of Assertions are : " << size << std::endl;
#endif
  exprt::operandst::const_iterator it=and_expr.begin();
  std::cout << "First single assertion push: " << *it << std::endl;
  if(size==1) {
    exprt::operandst::const_iterator it=and_expr.begin();
#ifdef DEBUG
    std::cout << "First single assertion push: " << *it << std::endl;
#endif
    exprt exp=*it;
    not_exprt not_exp(exp);
    push(worklist, not_exp);
  }
  else {
    and_exprt final_and;
    std::swap(final_and.operands(), and_expr);
    not_exprt not_exp(final_and);
#ifdef DEBUG
    std::cout << "First push: " << not_exp.pretty() << std::endl;
#endif
    push(worklist, not_exp);
  }
#endif

#if 0
  // **************************************************
  // Initialization Strategy: Add the first SSA element
  // **************************************************

  // check for equalities or constraints or next node
  if (SSA.nodes.empty ())
    return;
  assert(!SSA.nodes.front ().equalities.empty ());
  // insert the first SSA element on to the worklist
  push(worklist, SSA.nodes.front ().equalities.front ());
  #ifdef DEBUG
  std::cout << "First push: " << from_expr (SSA.ns, "", SSA.nodes.front().equalities.front ()) << std::endl;
  #endif
#endif
}