call new multiply_to_hi_product function in util library instead of multiply_to_hilo_product, where possible

Author: hurchalla

modular_arithmetic/CMakeLists.txt

@@ -75,7 +75,7 @@ include(FetchContent)
 FetchContent_Declare(
     hurchalla_util
     GIT_REPOSITORY https://github.com/hurchalla/util.git
-    GIT_TAG        5ff4af01d0a769968e56bc668f4c9a9ad1896749
+    GIT_TAG        ba38c2c5e1164e0e7ab480e4fc959c3a43183c0e
 )
 FetchContent_MakeAvailable(hurchalla_util)
 

montgomery_arithmetic/CMakeLists.txt

@@ -79,7 +79,7 @@ include(FetchContent)
 FetchContent_Declare(
     hurchalla_util
     GIT_REPOSITORY https://github.com/hurchalla/util.git
-    GIT_TAG        5ff4af01d0a769968e56bc668f4c9a9ad1896749
+    GIT_TAG        ba38c2c5e1164e0e7ab480e4fc959c3a43183c0e
 )
 FetchContent_MakeAvailable(hurchalla_util)
 

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyFullRange.h

@@ -350,12 +350,12 @@ class MontyFullRange final :
 
     // return the high word of the product, and write the low word of the
     // product to u_lo.
-    HURCHALLA_FORCE_INLINE T multiplyToHiLo(T& u_lo, V x, V y) const
+    HURCHALLA_FORCE_INLINE T multiplyToHiLo(T& HURCHALLA_RESTRICT u_lo, V x, V y) const
     {
         namespace hc = ::hurchalla;
         return hc::unsigned_multiply_to_hilo_product(u_lo, x.get(), y.get());
     }
-    HURCHALLA_FORCE_INLINE T squareToHiLo(T& u_lo, V x) const
+    HURCHALLA_FORCE_INLINE T squareToHiLo(T& HURCHALLA_RESTRICT u_lo, V x) const
     {
         namespace hc = ::hurchalla;
         return hc::unsigned_square_to_hilo_product(u_lo, x.get());

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyHalfRange.h

@@ -700,7 +700,7 @@ class MontyHalfRange final :
         HPBC_CLOCKWORK_POSTCONDITION2(0 <= u_hi && u_hi < n_);
         return u_hi;
     }
-    HURCHALLA_FORCE_INLINE T squareToHiLo(T& u_lo, V x) const
+    HURCHALLA_FORCE_INLINE T squareToHiLo(T& HURCHALLA_RESTRICT u_lo, V x) const
     {
         HPBC_CLOCKWORK_PRECONDITION2(isValid(x));
         namespace hc = ::hurchalla;

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyQuarterRange.h

@@ -491,12 +491,12 @@ class MontyQuarterRange final : public
 
     // return the high word of the product, and write the low word of the
     // product to u_lo.
-    HURCHALLA_FORCE_INLINE T multiplyToHiLo(T& u_lo, V x, V y) const
+    HURCHALLA_FORCE_INLINE T multiplyToHiLo(T& HURCHALLA_RESTRICT u_lo, V x, V y) const
     {
         namespace hc = ::hurchalla;
         return hc::unsigned_multiply_to_hilo_product(u_lo, x.get(), y.get());
     }
-    HURCHALLA_FORCE_INLINE T squareToHiLo(T& u_lo, V x) const
+    HURCHALLA_FORCE_INLINE T squareToHiLo(T& HURCHALLA_RESTRICT u_lo, V x) const
     {
         namespace hc = ::hurchalla;
         return hc::unsigned_square_to_hilo_product(u_lo, x.get());

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/experimental/MontyFullRangeMasked.h

@@ -424,7 +424,7 @@ class MontyFullRangeMasked final :
 
     // This function computes the full two-word product of x*x.  It returns the
     // high word of x*x, and writes the low word of x*x to u_lo.
-    HURCHALLA_FORCE_INLINE T squareToHiLo(T& u_lo, V x) const
+    HURCHALLA_FORCE_INLINE T squareToHiLo(T& HURCHALLA_RESTRICT u_lo, V x) const
     {
         HPBC_CLOCKWORK_PRECONDITION2(isValid(x));
         T a = x.getbits();

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/low_level_api/detail/platform_specific/ImplRedc.h

@@ -13,7 +13,7 @@
 #include "hurchalla/modular_arithmetic/modular_subtraction.h"
 #include "hurchalla/util/traits/ut_numeric_limits.h"
 #include "hurchalla/util/traits/safely_promote_unsigned.h"
-#include "hurchalla/util/unsigned_multiply_to_hilo_product.h"
+#include "hurchalla/util/unsigned_multiply_to_hi_product.h"
 #include "hurchalla/util/conditional_select.h"
 #include "hurchalla/util/compiler_macros.h"
 #include "hurchalla/modular_arithmetic/detail/clockwork_programming_by_contract.h"
@@ -105,8 +105,13 @@ struct RedcIncomplete {
     // compute  m = (u * inv_n) % R
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
 
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    //T mn_lo;
+    // since we now skip calculating mn_lo (it's not used anyway), by calling
+    // unsigned_multiply_to_hi_product(), mn_lo can be considered to be an
+    // implied variable for explanation purposes, rather than a programming
+    // variable.
+    //T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
 
     // mn = m*n.  Since m = (u_lo*inv_n)%R, we know m < R, and thus  mn < R*n.
     // Therefore mn == mn_hi*R + mn_lo < R*n, and mn_hi*R < R*n - mn_lo <= R*n,
@@ -139,7 +144,9 @@ struct RedcIncomplete {
     // We simply disregard the low words of the minuend and subtrahend, since
     // they are equal to each other.
         // *** Assertion #2 ***
-    HPBC_CLOCKWORK_ASSERT2(u_lo == mn_lo);
+    // since we skip calculting the unused variable mn_lo, we can't actually
+    // call this assert anymore, even though it would be true.
+    //HPBC_CLOCKWORK_ASSERT2(u_lo == mn_lo);
 
     // Since u_hi and u_lo are type T (which is unsigned) variables, both
     // u_hi >= 0 and u_lo >= 0, and thus  u = u_hi*R + u_lo >= 0.  Along with
@@ -511,8 +518,7 @@ struct RedcStandard<__uint128_t>
     HPBC_CLOCKWORK_PRECONDITION2(n > 1);
 
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
     HPBC_CLOCKWORK_ASSERT2(mn_hi < n);
     T reg = u_hi + n;
 
@@ -574,8 +580,7 @@ struct RedcStandard<std::uint64_t>
     HPBC_CLOCKWORK_PRECONDITION2(n > 1);
 
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
     HPBC_CLOCKWORK_ASSERT2(mn_hi < n);
     T reg = u_hi + n;
     T uhi = u_hi;
@@ -624,8 +629,7 @@ struct RedcStandard<std::uint32_t>
     HPBC_CLOCKWORK_PRECONDITION2(n > 1);
 
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
     HPBC_CLOCKWORK_ASSERT2(mn_hi < n);
     T reg = u_hi + n;
     T uhi = u_hi;
@@ -683,8 +687,7 @@ struct RedcStandard<__uint128_t>
     HPBC_CLOCKWORK_PRECONDITION2(n > 1);
 
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
     HPBC_CLOCKWORK_ASSERT2(mn_hi < n);
     T reg = u_hi + n;
 
@@ -746,8 +749,7 @@ struct RedcStandard<std::uint64_t>
     HPBC_CLOCKWORK_PRECONDITION2(n > 1);
 
     T m = static_cast<T>(static_cast<P>(u_lo) * static_cast<P>(inv_n));
-    T mn_lo;
-    T mn_hi = ::hurchalla::unsigned_multiply_to_hilo_product(mn_lo, m, n);
+    T mn_hi = ::hurchalla::unsigned_multiply_to_hi_product(m, n);
     HPBC_CLOCKWORK_ASSERT2(mn_hi < n);
     T reg = u_hi + n;