Add implementation of multiplication operator bvmul.

Also add tests for its conversion from `mult_exprt` and of the factory
integrity.

Author: NlightNFotis

src/solvers/smt2_incremental/convert_expr_to_smt.cpp

@@ -383,8 +383,12 @@ convert_expr_to_smt(const euclidean_mod_exprt &euclidean_modulo)
 
 static smt_termt convert_expr_to_smt(const mult_exprt &multiply)
 {
-  UNIMPLEMENTED_FEATURE(
-    "Generation of SMT formula for multiply expression: " + multiply.pretty());
+  for(const auto &op : multiply.operands())
+  {
+    PRECONDITION(can_cast_type<bitvector_typet>(op.type()));
+  }
+  return convert_multiary_operator_to_terms(
+    multiply, smt_bit_vector_theoryt::multiplication);
 }
 
 static smt_termt convert_expr_to_smt(const address_of_exprt &address_of)

src/solvers/smt2_incremental/smt_bit_vector_theory.cpp

@@ -91,3 +91,29 @@ void smt_bit_vector_theoryt::subtractiont::validate(
 const smt_function_application_termt::factoryt<
   smt_bit_vector_theoryt::subtractiont>
   smt_bit_vector_theoryt::subtraction{};
+
+const char *smt_bit_vector_theoryt::multiplicationt::identifier()
+{
+  return "bvmul";
+}
+
+smt_sortt smt_bit_vector_theoryt::multiplicationt::return_sort(
+  const smt_termt &lhs,
+  const smt_termt &rhs)
+{
+  // For now, make sure that they have the same bit-width
+  multiplicationt::validate(lhs, rhs);
+  const auto width = lhs.get_sort().cast<smt_bit_vector_sortt>()->bit_width();
+  return smt_bit_vector_sortt{width};
+}
+
+void smt_bit_vector_theoryt::multiplicationt::validate(
+  const smt_termt &lhs,
+  const smt_termt &rhs)
+{
+  validate_bit_vector_predicate_arguments(lhs, rhs);
+}
+
+const smt_function_application_termt::factoryt<
+  smt_bit_vector_theoryt::multiplicationt>
+  smt_bit_vector_theoryt::multiplication{};

src/solvers/smt2_incremental/smt_bit_vector_theory.h

@@ -37,6 +37,15 @@ class smt_bit_vector_theoryt
   };
   static const smt_function_application_termt::factoryt<subtractiont>
     subtraction;
+
+  struct multiplicationt final
+  {
+    static const char *identifier();
+    static smt_sortt return_sort(const smt_termt &lhs, const smt_termt &rhs);
+    static void validate(const smt_termt &lhs, const smt_termt &rhs);
+  };
+  static const smt_function_application_termt::factoryt<multiplicationt>
+    multiplication;
 };
 
 #endif // CPROVER_SOLVERS_SMT2_INCREMENTAL_SMT_BIT_VECTOR_THEORY_H

unit/solvers/smt2_incremental/convert_expr_to_smt.cpp

@@ -321,4 +321,21 @@ TEST_CASE(
     REQUIRE_THROWS(
       convert_expr_to_smt(minus_exprt{true_exprt{}, false_exprt{}}));
   }
+
+  SECTION("Multiplication of two constant size bit-vectors")
+  {
+    const auto constructed_term =
+      convert_expr_to_smt(mult_exprt{one_bvint, two_bvint});
+    const auto expected_term =
+      smt_bit_vector_theoryt::multiplication(smt_term_one, smt_term_two);
+    CHECK(constructed_term == expected_term);
+  }
+
+  SECTION(
+    "Ensure that multiplication node conversion fails if the operands are not "
+    "bit-vector based")
+  {
+    const cbmc_invariants_should_throwt invariants_throw;
+    REQUIRE_THROWS(convert_expr_to_smt(mult_exprt{one_bvint, false_exprt{}}));
+  }
 }

unit/solvers/smt2_incremental/smt_bit_vector_theory.cpp

@@ -206,4 +206,17 @@ TEST_CASE(
     REQUIRE(function_application.arguments()[0].get() == two);
     REQUIRE(function_application.arguments()[1].get() == three);
   }
+
+  SECTION("Multiplication")
+  {
+    const auto function_application =
+      smt_bit_vector_theoryt::multiplication(two, three);
+    REQUIRE(
+      function_application.function_identifier() ==
+      smt_identifier_termt("bvmul", smt_bit_vector_sortt{8}));
+    REQUIRE(function_application.get_sort() == smt_bit_vector_sortt{8});
+    REQUIRE(function_application.arguments().size() == 2);
+    REQUIRE(function_application.arguments()[0].get() == two);
+    REQUIRE(function_application.arguments()[1].get() == three);
+  }
 }