Merge pull request #3109 from diffblue/bv2integer_irep

switch bv2integer and integer2bv to irep_idt

Author: kroening

src/ansi-c/expr2c.cpp

@@ -1814,7 +1814,7 @@ std::string expr2ct::convert_constant(
     const bool is_signed = c_enum_type.subtype().id() == ID_signedbv;
     const auto width = to_bitvector_type(c_enum_type.subtype()).get_width();
 
-    mp_integer int_value = bv2integer(id2string(value), width, is_signed);
+    mp_integer int_value = bvrep2integer(value, width, is_signed);
     mp_integer i=0;
 
     irep_idt int_value_string=integer2string(int_value);
@@ -1853,7 +1853,7 @@ std::string expr2ct::convert_constant(
     const auto width = to_bitvector_type(type).get_width();
 
     mp_integer int_value =
-      bv2integer(id2string(value), width, type.id() == ID_signedbv);
+      bvrep2integer(value, width, type.id() == ID_signedbv);
 
     const irep_idt &c_type=
       type.id()==ID_c_bit_field?type.subtype().get(ID_C_c_type):

src/ansi-c/literals/convert_float_literal.cpp

@@ -13,7 +13,6 @@ Author: Daniel Kroening, kroening@kroening.com
 
 #include <cassert>
 
-#include <util/arith_tools.h>
 #include <util/c_types.h>
 #include <util/config.h>
 #include <util/ieee_float.h>
@@ -85,12 +84,13 @@ exprt convert_float_literal(const std::string &src)
   else
     UNREACHABLE;
 
-  constant_exprt result(integer2bv(a.pack(), a.spec.width()), type);
+  const constant_exprt result = a.to_expr();
 
   if(parsed_float.is_imaginary)
   {
     const complex_typet complex_type(type);
-    return complex_exprt(from_integer(0, type), result, complex_type);
+    return complex_exprt(
+      ieee_floatt::zero(type).to_expr(), result, complex_type);
   }
 
   return result;

src/goto-cc/linker_script_merge.cpp

@@ -566,7 +566,7 @@ int linker_script_merget::ls_data2instructions(
     symbol_exprt lhs(d["sym"].value, pointer_type(char_type()));
 
     constant_exprt rhs(
-      integer2bv(
+      integer2bvrep(
         string2integer(id2string(symbol_value)),
         unsigned_int_type().get_width()),
       unsigned_int_type());
@@ -630,7 +630,7 @@ int linker_script_merget::ls_data2instructions(
     symbol_exprt lhs(d["sym"].value, pointer_type(char_type()));
 
     constant_exprt rhs;
-    rhs.set_value(integer2bv(
+    rhs.set_value(integer2bvrep(
       string2integer(d["val"].value), unsigned_int_type().get_width()));
     rhs.type()=unsigned_int_type();
 

src/goto-programs/goto_trace.cpp

@@ -140,7 +140,8 @@ static std::string numeric_representation(
 
   if(options.hex_representation)
   {
-    mp_integer value_int = bv2integer(id2string(value), value.size(), false);
+    const mp_integer value_int =
+      bvrep2integer(to_constant_expr(expr).get_value(), value.size(), false);
     result = integer2string(value_int, 16);
     prefix = "0x";
   }

src/goto-programs/interpreter_evaluate.cpp

@@ -383,7 +383,7 @@ void interpretert::evaluate(
     {
       const irep_idt &value=to_constant_expr(expr).get_value();
       const auto width = to_c_bool_type(expr.type()).get_width();
-      dest.push_back(bv2integer(id2string(value), width, false));
+      dest.push_back(bvrep2integer(value, width, false));
       return;
     }
     else if(expr.type().id()==ID_bool)
@@ -985,15 +985,15 @@ void interpretert::evaluate(
       else if(expr.type().id()==ID_signedbv)
       {
         const auto width = to_signedbv_type(expr.type()).get_width();
-        const std::string s = integer2bv(value, width);
-        dest.push_back(bv2integer(s, width, true));
+        const auto s = integer2bvrep(value, width);
+        dest.push_back(bvrep2integer(s, width, true));
         return;
       }
       else if(expr.type().id()==ID_unsignedbv)
       {
         const auto width = to_unsignedbv_type(expr.type()).get_width();
-        const std::string s = integer2bv(value, width);
-        dest.push_back(bv2integer(s, width, false));
+        const auto s = integer2bvrep(value, width);
+        dest.push_back(bvrep2integer(s, width, false));
         return;
       }
       else if((expr.type().id()==ID_bool) || (expr.type().id()==ID_c_bool))

src/solvers/flattening/boolbv_constant.cpp

@@ -91,7 +91,7 @@ bvt boolbvt::convert_constant(const constant_exprt &expr)
 
     for(std::size_t i=0; i<width; i++)
     {
-      const bool bit = get_bitvector_bit(value, width, i);
+      const bool bit = get_bvrep_bit(value, width, i);
       bv[i]=const_literal(bit);
     }
 

src/solvers/lowering/popcount.cpp

@@ -48,7 +48,7 @@ exprt lower_popcount(const popcount_exprt &expr, const namespacet &ns)
     for(std::size_t i = 0; i < new_width / (2 * shift); ++i)
       bitstring += std::string(shift, '0') + std::string(shift, '1');
     const mp_integer value = binary2integer(bitstring, false);
-    constant_exprt bitmask(integer2bv(value, new_width), x.type());
+    const constant_exprt bitmask(integer2bvrep(value, new_width), x.type());
     // build the expression
     x = plus_exprt(bitand_exprt(x, bitmask), bitand_exprt(shifted_x, bitmask));
   }

src/util/arith_tools.cpp

@@ -44,19 +44,19 @@ bool to_integer(const constant_exprt &expr, mp_integer &int_value)
   else if(type_id==ID_unsignedbv)
   {
     const auto width = to_unsignedbv_type(type).get_width();
-    int_value = bv2integer(id2string(value), width, false);
+    int_value = bvrep2integer(value, width, false);
     return false;
   }
   else if(type_id==ID_signedbv)
   {
     const auto width = to_signedbv_type(type).get_width();
-    int_value = bv2integer(id2string(value), width, true);
+    int_value = bvrep2integer(value, width, true);
     return false;
   }
   else if(type_id==ID_c_bool)
   {
     const auto width = to_c_bool_type(type).get_width();
-    int_value = bv2integer(id2string(value), width, false);
+    int_value = bvrep2integer(value, width, false);
     return false;
   }
   else if(type_id==ID_c_enum)
@@ -65,13 +65,13 @@ bool to_integer(const constant_exprt &expr, mp_integer &int_value)
     if(subtype.id()==ID_signedbv)
     {
       const auto width = to_signedbv_type(type).get_width();
-      int_value = bv2integer(id2string(value), width, true);
+      int_value = bvrep2integer(value, width, true);
       return false;
     }
     else if(subtype.id()==ID_unsignedbv)
     {
       const auto width = to_unsignedbv_type(type).get_width();
-      int_value = bv2integer(id2string(value), width, false);
+      int_value = bvrep2integer(value, width, false);
       return false;
     }
   }
@@ -83,17 +83,17 @@ bool to_integer(const constant_exprt &expr, mp_integer &int_value)
 
     if(subtype.id()==ID_signedbv)
     {
-      int_value = bv2integer(id2string(value), width, true);
+      int_value = bvrep2integer(value, width, true);
       return false;
     }
     else if(subtype.id()==ID_unsignedbv)
     {
-      int_value = bv2integer(id2string(value), width, false);
+      int_value = bvrep2integer(value, width, false);
       return false;
     }
     else if(subtype.id() == ID_c_bool)
     {
-      int_value = bv2integer(id2string(value), width, false);
+      int_value = bvrep2integer(value, width, false);
       return false;
     }
   }
@@ -136,28 +136,28 @@ constant_exprt from_integer(
   else if(type_id==ID_unsignedbv)
   {
     std::size_t width=to_unsignedbv_type(type).get_width();
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_bv)
   {
     std::size_t width=to_bv_type(type).get_width();
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_signedbv)
   {
     std::size_t width=to_signedbv_type(type).get_width();
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_c_enum)
   {
     const std::size_t width =
       to_c_enum_type(type).subtype().get_size_t(ID_width);
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_c_bool)
   {
     std::size_t width=to_c_bool_type(type).get_width();
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_bool)
   {
@@ -175,7 +175,7 @@ constant_exprt from_integer(
   else if(type_id==ID_c_bit_field)
   {
     std::size_t width=to_c_bit_field_type(type).get_width();
-    return constant_exprt(integer2bv(int_value, width), type);
+    return constant_exprt(integer2bvrep(int_value, width), type);
   }
   else if(type_id==ID_fixedbv)
   {
@@ -280,7 +280,7 @@ void mp_max(mp_integer &a, const mp_integer &b)
 /// \param src: the bitvector representation
 /// \param width: the number of bits in the bitvector
 /// \param bit_index: index (0 is the least significant)
-bool get_bitvector_bit(
+bool get_bvrep_bit(
   const irep_idt &src,
   std::size_t width,
   std::size_t bit_index)
@@ -314,14 +314,14 @@ make_bvrep(const std::size_t width, const std::function<bool(std::size_t)> f)
 /// \param width: the width of the bit-vector
 /// \param f: the functor
 /// \returns new bitvector representation
-irep_idt bitvector_bitwise_op(
+irep_idt bvrep_bitwise_op(
   const irep_idt &a,
   const irep_idt &b,
   const std::size_t width,
   const std::function<bool(bool, bool)> f)
 {
   return make_bvrep(width, [&a, &b, &width, f](std::size_t i) {
-    return f(get_bitvector_bit(a, width, i), get_bitvector_bit(b, width, i));
+    return f(get_bvrep_bit(a, width, i), get_bvrep_bit(b, width, i));
   });
 }
 
@@ -331,12 +331,25 @@ irep_idt bitvector_bitwise_op(
 /// \param width: the width of the bit-vector
 /// \param f: the functor
 /// \returns new bitvector representation
-irep_idt bitvector_bitwise_op(
+irep_idt bvrep_bitwise_op(
   const irep_idt &a,
   const std::size_t width,
   const std::function<bool(bool)> f)
 {
   return make_bvrep(width, [&a, &width, f](std::size_t i) {
-    return f(get_bitvector_bit(a, width, i));
+    return f(get_bvrep_bit(a, width, i));
   });
 }
+
+/// convert an integer to bit-vector representation with given width
+irep_idt integer2bvrep(const mp_integer &src, std::size_t width)
+{
+  return integer2binary(src, width);
+}
+
+/// convert a bit-vector representation (possibly signed) to integer
+mp_integer bvrep2integer(const irep_idt &src, std::size_t width, bool is_signed)
+{
+  PRECONDITION(src.size() == width);
+  return binary2integer(id2string(src), is_signed);
+}

src/util/arith_tools.h

@@ -164,12 +164,15 @@ mp_integer power(const mp_integer &base, const mp_integer &exponent);
 void mp_min(mp_integer &a, const mp_integer &b);
 void mp_max(mp_integer &a, const mp_integer &b);
 
-bool get_bitvector_bit(
+bool get_bvrep_bit(
   const irep_idt &src,
   std::size_t width,
   std::size_t bit_index);
 
 irep_idt
 make_bvrep(const std::size_t width, const std::function<bool(std::size_t)> f);
 
+irep_idt integer2bvrep(const mp_integer &, std::size_t width);
+mp_integer bvrep2integer(const irep_idt &, std::size_t width, bool is_signed);
+
 #endif // CPROVER_UTIL_ARITH_TOOLS_H

src/util/bv_arithmetic.cpp

@@ -84,7 +84,7 @@ mp_integer bv_arithmetict::pack() const
 
 exprt bv_arithmetict::to_expr() const
 {
-  return constant_exprt(integer2bv(value, spec.width), spec.to_type());
+  return constant_exprt(integer2bvrep(value, spec.width), spec.to_type());
 }
 
 bv_arithmetict &bv_arithmetict::operator/=(const bv_arithmetict &other)
@@ -184,5 +184,6 @@ void bv_arithmetict::from_expr(const exprt &expr)
 {
   PRECONDITION(expr.is_constant());
   spec=bv_spect(expr.type());
-  value = bv2integer(expr.get_string(ID_value), spec.width, spec.is_signed);
+  value = bvrep2integer(
+    to_constant_expr(expr).get_value(), spec.width, spec.is_signed);
 }